unassign

Author: FoseFx

gen/go/libs/common/v1/conflict.pb.go

@@ -22,5 +22,5 @@ message Conflict {
 
 message AttributeConflict {
   google.protobuf.Any is = 1; // CAUTION: may be missing, if the is underlying value is missing (e.g., unassigned beds)
-  google.protobuf.Any want = 2;
+  google.protobuf.Any want = 2; // CAUTION: may be missing, if the requested value is missing (e.g., unassignment of a bed)
 }

proto/libs/common/v1/conflict.proto

@@ -545,9 +545,49 @@ func (s *PatientGrpcService) UnassignBed(ctx context.Context, req *pb.UnassignBe
 		return nil, err
 	}
 
-	consistency, err := s.handlers.Commands.V1.UnassignBed(ctx, patientID)
-	if err != nil {
-		return nil, err
+	expConsistency, ok := hwutil.ParseConsistency(req.Consistency)
+	if !ok {
+		return nil, common.UnparsableConsistencyError(ctx, "consistency")
+	}
+
+	var consistency uint64
+
+	for i := 0; true; i++ {
+		if i > 10 {
+			log.Warn().Msg("AssignBed: conflict circuit breaker triggered")
+			return nil, fmt.Errorf("failed conflict resolution")
+		}
+
+		c, conflict, err := s.handlers.Commands.V1.UnassignBed(ctx, patientID, expConsistency)
+		if err != nil {
+			return nil, err
+		}
+		consistency = c
+		if conflict == nil {
+			break
+		}
+		conflicts := make(map[string]*commonpb.AttributeConflict)
+
+		// TODO: find a generic approach
+		if conflict.Is.BedID.Valid && conflict.Was.BedID != conflict.Is.BedID {
+			conflicts["bed_id"], err = util.AttributeConflict(
+				wrapperspb.String(conflict.Is.BedID.UUID.String()),
+				nil,
+			)
+			if err != nil {
+				return nil, err
+			}
+		}
+
+		if len(conflicts) != 0 {
+			return &pb.UnassignBedResponse{
+				Conflict:    &commonpb.Conflict{ConflictingAttributes: conflicts},
+				Consistency: strconv.FormatUint(conflict.Consistency, 10),
+			}, nil
+		}
+
+		// no conflict? retry with new consistency
+		expConsistency = &conflict.Consistency
 	}
 
 	log.Info().Str("patientID", patientID.String()).Msg("unassigned bed from patient")

services/tasks-svc/internal/patient/api/grpc.go

@@ -5,20 +5,37 @@ import (
 	"github.com/google/uuid"
 	"hwes"
 	"tasks-svc/internal/patient/aggregate"
+	"tasks-svc/internal/patient/models"
 )
 
-type UnassignBedCommandHandler func(ctx context.Context, patientID uuid.UUID) (uint64, error)
+type UnassignBedConflict struct {
+	Consistency uint64
+	Was         *models.Patient
+	Is          *models.Patient
+}
+
+type UnassignBedCommandHandler func(ctx context.Context, patientID uuid.UUID, expectedConsistency *uint64) (uint64, *UnassignBedConflict, error)
 
 func NewUnassignBedCommandHandler(as hwes.AggregateStore) UnassignBedCommandHandler {
-	return func(ctx context.Context, patientID uuid.UUID) (uint64, error) {
-		a, err := aggregate.LoadPatientAggregate(ctx, as, patientID)
+	return func(ctx context.Context, patientID uuid.UUID, expectedConsistency *uint64) (uint64, *UnassignBedConflict, error) {
+		a, oldState, err := aggregate.LoadPatientAggregateWithSnapshotAt(ctx, as, patientID, expectedConsistency)
 		if err != nil {
-			return 0, err
+			return 0, nil, err
+		}
+
+		// update has happened since
+		if expectedConsistency != nil && *expectedConsistency != a.GetVersion() {
+			return 0, &UnassignBedConflict{
+				Consistency: a.GetVersion(),
+				Was:         oldState,
+				Is:          a.Patient,
+			}, nil
 		}
 
 		if err := a.UnassignBed(ctx); err != nil {
-			return 0, err
+			return 0, nil, err
 		}
-		return as.Save(ctx, a)
+		consistency, err := as.Save(ctx, a)
+		return consistency, nil, err
 	}
 }

services/tasks-svc/internal/patient/commands/v1/unassign_bed.go

@@ -838,3 +838,87 @@ func TestAssignBedConflict(t *testing.T) {
 		})
 	}
 }
+
+func TestUnassignBedConflict(t *testing.T) {
+	ctx := context.Background()
+	patientClient := patientServiceClient()
+
+	wardId, _ := prepareWard(t, ctx, "")
+	roomId, _ := prepareRoom(t, ctx, wardId, "")
+
+	A, _ := prepareBed(t, ctx, roomId, "A")
+	B, _ := prepareBed(t, ctx, roomId, "B")
+
+	testMatrix := []struct {
+		was            string
+		is             *string
+		expectConflict bool
+	}{
+		{A, &B, true},
+		{A, &A, false},
+		{A, nil, false},
+	}
+
+	for i, o := range testMatrix {
+		t.Run(t.Name()+"_"+strconv.Itoa(i), func(t *testing.T) {
+			// WAS
+			patientRes, err := patientClient.CreatePatient(ctx, &pb.CreatePatientRequest{
+				HumanReadableIdentifier: t.Name(),
+				Notes:                   hwutil.PtrTo("A patient for test " + t.Name()),
+			})
+			assert.NoError(t, err)
+			time.Sleep(time.Millisecond * 100)
+
+			initialAssignment, err := patientClient.AssignBed(ctx, &pb.AssignBedRequest{
+				Id:          patientRes.Id,
+				BedId:       o.was,
+				Consistency: &patientRes.Consistency,
+			})
+			assert.NoError(t, err)
+			assert.Nil(t, initialAssignment.Conflict)
+
+			id := patientRes.Id
+			initialConsistency := initialAssignment.Consistency
+
+			time.Sleep(time.Millisecond * 100)
+
+			// IS
+			if o.is != nil {
+				a, err := patientClient.AssignBed(ctx, &pb.AssignBedRequest{
+					Id:          id,
+					BedId:       *o.is,
+					Consistency: &initialConsistency,
+				})
+				assert.NoError(t, err)
+				assert.Nil(t, a.Conflict)
+			} else {
+				u, err := patientClient.UnassignBed(ctx, &pb.UnassignBedRequest{
+					Id:          id,
+					Consistency: &initialConsistency,
+				})
+				assert.NoError(t, err)
+				assert.Nil(t, u.Conflict)
+			}
+			time.Sleep(time.Millisecond * 100)
+
+			// WANT
+			updateRes, err := patientClient.UnassignBed(ctx, &pb.UnassignBedRequest{
+				Id:          id,
+				Consistency: &initialConsistency,
+			})
+			assert.NoError(t, err)
+
+			// EXPECT
+			assert.Equal(t, o.expectConflict, updateRes.Conflict != nil)
+			if o.expectConflict {
+				conflict := updateRes.Conflict.ConflictingAttributes["bed_id"]
+				assert.NotNil(t, conflict)
+				exp := ""
+				if o.is != nil {
+					exp = "is:{[type.googleapis.com/google.protobuf.StringValue]:{value:\"" + *o.is + "\"}}"
+				}
+				assert.Equal(t, exp, conflict.String())
+			}
+		})
+	}
+}