Merge pull request #27 from helpwave/patch/patient-location-split

split up patient location into clinic, position and teams

Author: felixevers

backend/api/inputs.py

@@ -69,6 +69,9 @@ class CreatePatientInput:
     sex: Sex
     assigned_location_id: strawberry.ID | None = None
     assigned_location_ids: list[strawberry.ID] | None = None
+    clinic_id: strawberry.ID  # Required: location node from kind CLINIC
+    position_id: strawberry.ID | None = None  # Optional: location node from type hospital, practice, clinic, ward, bed or room
+    team_ids: list[strawberry.ID] | None = None  # Array: location nodes from type clinic, team, practice, hospital
     properties: list[PropertyValueInput] | None = None
     state: PatientState | None = None
 
@@ -81,6 +84,9 @@ class UpdatePatientInput:
     sex: Sex | None = None
     assigned_location_id: strawberry.ID | None = None
     assigned_location_ids: list[strawberry.ID] | None = None
+    clinic_id: strawberry.ID | None = None  # Location node from kind CLINIC
+    position_id: strawberry.ID | None = None  # Optional: location node from type hospital, practice, clinic, ward, bed or room
+    team_ids: list[strawberry.ID] | None = None  # Array: location nodes from type clinic, team, practice, hospital
     properties: list[PropertyValueInput] | None = None
 
 

backend/api/resolvers/patient.py

@@ -12,6 +12,35 @@
 from .utils import process_properties
 
 
+def validate_location_kind(location: models.LocationNode, expected_kind: str, field_name: str) -> None:
+    """Validate that a location has the expected kind."""
+    if location.kind.upper() != expected_kind.upper():
+        raise Exception(
+            f"{field_name} must be a location of kind {expected_kind}, "
+            f"but got {location.kind}"
+        )
+
+
+def validate_position_kind(location: models.LocationNode, field_name: str) -> None:
+    """Validate that a location is a valid position type."""
+    allowed_kinds = {"HOSPITAL", "PRACTICE", "CLINIC", "WARD", "BED", "ROOM"}
+    if location.kind.upper() not in allowed_kinds:
+        raise Exception(
+            f"{field_name} must be a location of kind HOSPITAL, PRACTICE, CLINIC, "
+            f"WARD, BED, or ROOM, but got {location.kind}"
+        )
+
+
+def validate_team_kind(location: models.LocationNode, field_name: str) -> None:
+    """Validate that a location is a valid team type."""
+    allowed_kinds = {"CLINIC", "TEAM", "PRACTICE", "HOSPITAL"}
+    if location.kind.upper() not in allowed_kinds:
+        raise Exception(
+            f"{field_name} must be a location of kind CLINIC, TEAM, PRACTICE, "
+            f"or HOSPITAL, but got {location.kind}"
+        )
+
+
 @strawberry.type
 class PatientQuery:
     @strawberry.field
@@ -26,6 +55,7 @@ async def patient(
             .options(
                 selectinload(models.Patient.assigned_locations),
                 selectinload(models.Patient.tasks),
+                selectinload(models.Patient.teams),
             ),
         )
         return result.scalars().first()
@@ -40,6 +70,7 @@ async def patients(
         query = select(models.Patient).options(
             selectinload(models.Patient.assigned_locations),
             selectinload(models.Patient.tasks),
+            selectinload(models.Patient.teams),
         )
 
         if states:
@@ -88,6 +119,7 @@ async def recent_patients(
             .options(
                 selectinload(models.Patient.assigned_locations),
                 selectinload(models.Patient.tasks),
+                selectinload(models.Patient.teams),
             )
             .limit(limit)
         )
@@ -103,26 +135,70 @@ async def create_patient(
         info: Info,
         data: CreatePatientInput,
     ) -> PatientType:
+        db = info.context.db
         initial_state = data.state.value if data.state else PatientState.WAIT.value
+        
+        clinic_result = await db.execute(
+            select(models.LocationNode).where(
+                models.LocationNode.id == data.clinic_id,
+            ),
+        )
+        clinic = clinic_result.scalars().first()
+        if not clinic:
+            raise Exception(f"Clinic location with id {data.clinic_id} not found")
+        validate_location_kind(clinic, "CLINIC", "clinic_id")
+
+        position = None
+        if data.position_id:
+            position_result = await db.execute(
+                select(models.LocationNode).where(
+                    models.LocationNode.id == data.position_id,
+                ),
+            )
+            position = position_result.scalars().first()
+            if not position:
+                raise Exception(f"Position location with id {data.position_id} not found")
+            validate_position_kind(position, "position_id")
+
+        teams = []
+        if data.team_ids:
+            teams_result = await db.execute(
+                select(models.LocationNode).where(
+                    models.LocationNode.id.in_(data.team_ids),
+                ),
+            )
+            teams = list(teams_result.scalars().all())
+            if len(teams) != len(data.team_ids):
+                found_ids = {t.id for t in teams}
+                missing_ids = set(data.team_ids) - found_ids
+                raise Exception(f"Team locations with ids {missing_ids} not found")
+            for team in teams:
+                validate_team_kind(team, "team_ids")
+
         new_patient = models.Patient(
             firstname=data.firstname,
             lastname=data.lastname,
             birthdate=data.birthdate,
             sex=data.sex.value,
             state=initial_state,
             assigned_location_id=data.assigned_location_id,
+            clinic_id=data.clinic_id,
+            position_id=data.position_id,
         )
 
+        if teams:
+            new_patient.teams = teams
+
         if data.assigned_location_ids:
-            result = await info.context.db.execute(
+            result = await db.execute(
                 select(models.LocationNode).where(
                     models.LocationNode.id.in_(data.assigned_location_ids),
                 ),
             )
             locations = result.scalars().all()
             new_patient.assigned_locations = list(locations)
         elif data.assigned_location_id:
-            result = await info.context.db.execute(
+            result = await db.execute(
                 select(models.LocationNode).where(
                     models.LocationNode.id == data.assigned_location_id,
                 ),
@@ -133,16 +209,16 @@ async def create_patient(
 
         if data.properties:
             await process_properties(
-                info.context.db,
+                db,
                 new_patient,
                 data.properties,
                 "patient",
             )
 
-        info.context.db.add(new_patient)
-        await info.context.db.commit()
+        db.add(new_patient)
+        await db.commit()
 
-        await info.context.db.refresh(new_patient, ["assigned_locations"])
+        await db.refresh(new_patient, ["assigned_locations", "teams"])
         await redis_client.publish("patient_created", new_patient.id)
         return new_patient
 
@@ -157,7 +233,10 @@ async def update_patient(
         result = await db.execute(
             select(models.Patient)
             .where(models.Patient.id == id)
-            .options(selectinload(models.Patient.assigned_locations)),
+            .options(
+                selectinload(models.Patient.assigned_locations),
+                selectinload(models.Patient.teams),
+            ),
         )
         patient = result.scalars().first()
         if not patient:
@@ -172,6 +251,49 @@ async def update_patient(
         if data.sex is not None:
             patient.sex = data.sex.value
 
+        # Update clinic (if provided)
+        if data.clinic_id is not None:
+            clinic_result = await db.execute(
+                select(models.LocationNode).where(
+                    models.LocationNode.id == data.clinic_id,
+                ),
+            )
+            clinic = clinic_result.scalars().first()
+            if not clinic:
+                raise Exception(f"Clinic location with id {data.clinic_id} not found")
+            validate_location_kind(clinic, "CLINIC", "clinic_id")
+            patient.clinic_id = data.clinic_id
+
+        if data.position_id is not None:
+            position_result = await db.execute(
+                select(models.LocationNode).where(
+                    models.LocationNode.id == data.position_id,
+                ),
+            )
+            position = position_result.scalars().first()
+            if not position:
+                raise Exception(f"Position location with id {data.position_id} not found")
+            validate_position_kind(position, "position_id")
+            patient.position_id = data.position_id
+
+        if data.team_ids is not None:
+            if len(data.team_ids) == 0:
+                patient.teams = []
+            else:
+                teams_result = await db.execute(
+                    select(models.LocationNode).where(
+                        models.LocationNode.id.in_(data.team_ids),
+                    ),
+                )
+                teams = list(teams_result.scalars().all())
+                if len(teams) != len(data.team_ids):
+                    found_ids = {t.id for t in teams}
+                    missing_ids = set(data.team_ids) - found_ids
+                    raise Exception(f"Team locations with ids {missing_ids} not found")
+                for team in teams:
+                    validate_team_kind(team, "team_ids")
+                patient.teams = teams
+
         if data.assigned_location_ids is not None:
             result = await db.execute(
                 select(models.LocationNode).where(
@@ -196,7 +318,7 @@ async def update_patient(
             await process_properties(db, patient, data.properties, "patient")
 
         await db.commit()
-        await db.refresh(patient, ["assigned_locations"])
+        await db.refresh(patient, ["assigned_locations", "teams"])
         return patient
 
     @strawberry.mutation
@@ -218,7 +340,10 @@ async def admit_patient(self, info: Info, id: strawberry.ID) -> PatientType:
         result = await db.execute(
             select(models.Patient)
             .where(models.Patient.id == id)
-            .options(selectinload(models.Patient.assigned_locations)),
+            .options(
+                selectinload(models.Patient.assigned_locations),
+                selectinload(models.Patient.teams),
+            ),
         )
         patient = result.scalars().first()
         if not patient:
@@ -234,7 +359,10 @@ async def discharge_patient(self, info: Info, id: strawberry.ID) -> PatientType:
         result = await db.execute(
             select(models.Patient)
             .where(models.Patient.id == id)
-            .options(selectinload(models.Patient.assigned_locations)),
+            .options(
+                selectinload(models.Patient.assigned_locations),
+                selectinload(models.Patient.teams),
+            ),
         )
         patient = result.scalars().first()
         if not patient:
@@ -250,7 +378,10 @@ async def mark_patient_dead(self, info: Info, id: strawberry.ID) -> PatientType:
         result = await db.execute(
             select(models.Patient)
             .where(models.Patient.id == id)
-            .options(selectinload(models.Patient.assigned_locations)),
+            .options(
+                selectinload(models.Patient.assigned_locations),
+                selectinload(models.Patient.teams),
+            ),
         )
         patient = result.scalars().first()
         if not patient:
@@ -266,7 +397,10 @@ async def wait_patient(self, info: Info, id: strawberry.ID) -> PatientType:
         result = await db.execute(
             select(models.Patient)
             .where(models.Patient.id == id)
-            .options(selectinload(models.Patient.assigned_locations)),
+            .options(
+                selectinload(models.Patient.assigned_locations),
+                selectinload(models.Patient.teams),
+            ),
         )
         patient = result.scalars().first()
         if not patient:

backend/api/types/patient.py

@@ -23,6 +23,8 @@ class PatientType:
     sex: Sex
     state: PatientState
     assigned_location_id: strawberry.ID | None
+    clinic_id: strawberry.ID
+    position_id: strawberry.ID | None
 
     @strawberry.field
     def name(self) -> str:
@@ -81,6 +83,57 @@ async def assigned_locations(
         await info.context.db.refresh(self, ["assigned_locations"])
         return self.assigned_locations or []
 
+    @strawberry.field
+    async def clinic(
+        self,
+        info: Info,
+    ) -> Annotated[
+        "LocationNodeType",
+        strawberry.lazy("api.types.location"),
+    ]:
+        result = await info.context.db.execute(
+            select(models.LocationNode).where(
+                models.LocationNode.id == self.clinic_id,
+            ),
+        )
+        clinic = result.scalars().first()
+        if not clinic:
+            raise Exception(f"Clinic location not found for patient {self.id}")
+        return clinic
+
+    @strawberry.field
+    async def position(
+        self,
+        info: Info,
+    ) -> (
+        Annotated[
+            "LocationNodeType",
+            strawberry.lazy("api.types.location"),
+        ]
+        | None
+    ):
+        if not self.position_id:
+            return None
+        result = await info.context.db.execute(
+            select(models.LocationNode).where(
+                models.LocationNode.id == self.position_id,
+            ),
+        )
+        return result.scalars().first()
+
+    @strawberry.field
+    async def teams(
+        self,
+        info: Info,
+    ) -> list[
+        Annotated[
+            "LocationNodeType",
+            strawberry.lazy("api.types.location"),
+        ]
+    ]:
+        await info.context.db.refresh(self, ["teams"])
+        return self.teams or []
+
     @strawberry.field
     async def tasks(
         self,