healthdatalayer 1.0.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

healthdatalayer/repositories/infraestructure_repositories/branch_repository.py

@@ -0,0 +1,69 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+
+from models import Branch
+from config.db import engines, get_session
+
+class BranchRepository:
+    def __init__(self, tenant: str):
+        self.tenant = tenant
+        if tenant not in engines:
+            raise ValueError(f"Tenant {tenant} is not configured")
+    
+    def create_command(self, branch: Branch) -> Branch:
+        with get_session(self.tenant) as session:
+            session.add(branch)
+            session.commit()
+            session.refresh(branch)
+            return branch
+    
+    def get_by_id_command(self, branch_id: UUID) -> Optional[Branch]:
+        with get_session(self.tenant) as session:
+            return session.get(Branch, branch_id)
+    
+    def get_by_name_command(self, name: str) -> Optional[Branch]:
+        with get_session(self.tenant) as session:
+            statement = select(Branch).where(Branch.name == name)
+            result = session.exec(statement).first()
+            return result
+    
+    def list_all_command(self, active_only: bool = True) -> List[Branch]:
+        with get_session(self.tenant) as session:
+            statement = select(Branch)
+            
+            if active_only:
+                statement = statement.where(Branch.is_active == True)
+            
+            results = session.exec(statement)
+            return results.all()
+    
+    def update_command(self, branch_id: UUID, **kwargs) -> Optional[Branch]:
+        with get_session(self.tenant) as session:
+            db_branch = session.get(Branch, branch_id)
+            if not db_branch:
+                return None
+            
+            for key, value in kwargs.items():
+                if hasattr(db_branch, key):
+                    setattr(db_branch, key, value)
+            
+            session.add(db_branch)
+            session.commit()
+            session.refresh(db_branch)
+            return db_branch
+    
+    def delete_command(self, branch_id: UUID, soft_delete: bool = True) -> bool:
+        with get_session(self.tenant) as session:
+            db_branch = session.get(Branch, branch_id)
+            if not db_branch:
+                return False
+            
+            if soft_delete:
+                db_branch.is_active = False
+                session.add(db_branch)
+            else:
+                session.delete(db_branch)
+            
+            session.commit()
+            return True

healthdatalayer/repositories/infraestructure_repositories/bridge_repository.py

@@ -0,0 +1,80 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+from sqlalchemy.orm import selectinload,joinedload
+
+from models import BridgeAreaFloorBranch
+from models import Branch
+from config.db import engines, get_session
+
+class BridgeAreaFloorBranchRepository:
+    def __init__(self, tenant: str):
+        self.tenant = tenant
+        if tenant not in engines:
+            raise ValueError(f"Tenant {tenant} is not configured")
+
+    def create_command(self, bridge: BridgeAreaFloorBranch) -> BridgeAreaFloorBranch:
+        with get_session(self.tenant) as session:
+            session.add(bridge)
+            session.commit()
+            session.refresh(bridge)
+            return bridge
+
+    def get_by_id_command(self, bridge_id: UUID, load_related: bool = False) -> Optional[BridgeAreaFloorBranch]:
+        with get_session(self.tenant) as session:
+            statement = select(BridgeAreaFloorBranch).where(BridgeAreaFloorBranch.bridge_area_floor_branch_id == bridge_id)
+            if load_related:
+                statement = statement.options(
+                    selectinload(BridgeAreaFloorBranch.branch).selectinload(Branch.system),
+                    selectinload(BridgeAreaFloorBranch.area),
+                    selectinload(BridgeAreaFloorBranch.floor)
+                )
+            bridge = session.exec(statement).first()
+            
+                    
+            return bridge
+
+    def get_all_command(self, active_only: bool = True,load_related: bool = False) -> List[BridgeAreaFloorBranch]:
+        with get_session(self.tenant) as session:
+            statement = select(BridgeAreaFloorBranch)
+            if active_only:
+                statement = statement.where(BridgeAreaFloorBranch.is_active == True)
+            #results = session.exec(statement).all()
+            
+            if load_related:
+                statement = statement.options(
+                    selectinload(BridgeAreaFloorBranch.branch).selectinload(Branch.system),
+                    selectinload(BridgeAreaFloorBranch.area),
+                    selectinload(BridgeAreaFloorBranch.floor)
+                )
+               
+            results = session.exec(statement).all()
+            return results
+    
+    def update_command(self, bridge: BridgeAreaFloorBranch) -> BridgeAreaFloorBranch:
+        with get_session(self.tenant) as session:
+            existing_bridge = session.get(BridgeAreaFloorBranch, bridge.bridge_area_floor_branch_id)
+            if not existing_bridge:
+                raise ValueError(f"BridgeAreaFloorBranch with id {bridge.bridge_area_floor_branch_id} does not exist")
+            
+            for key, value in bridge.dict(exclude_unset=True).items():
+                setattr(existing_bridge, key, value)
+            
+            bd_bridge =  session.merge(existing_bridge)
+            session.commit()
+            session.refresh(bd_bridge)
+            return bd_bridge
+
+    def delete_command(self, bridge_id: UUID, soft_delete: bool = False) -> None:
+        with get_session(self.tenant) as session:
+            existing_bridge = session.get(BridgeAreaFloorBranch, bridge_id)
+            if not existing_bridge:
+                raise ValueError(f"BridgeAreaFloorBranch with id {bridge_id} does not exist")
+
+            if soft_delete:
+                existing_bridge.is_active = False
+                session.add(existing_bridge)
+            else:
+                session.delete(existing_bridge)
+
+            session.commit()

healthdatalayer/repositories/infraestructure_repositories/floor_repository.py

@@ -0,0 +1,69 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+
+from models import Floor
+from config.db import engines, get_session
+
+class FloorRepository:
+    def __init__(self, tenant: str):
+        self.tenant = tenant
+        if tenant not in engines:
+            raise ValueError(f"Tenant {tenant} is not configured")
+    
+    def create_command(self, floor: Floor) -> Floor:
+        with get_session(self.tenant) as session:
+            session.add(floor)
+            session.commit()
+            session.refresh(floor)
+            return floor
+    
+    def get_by_id_command(self, floor_id: UUID) -> Optional[Floor]:
+        with get_session(self.tenant) as session:
+            return session.get(Floor, floor_id)
+    
+    def get_by_name_command(self, name: str) -> Optional[Floor]:
+        with get_session(self.tenant) as session:
+            statement = select(Floor).where(Floor.name == name)
+            result = session.exec(statement).first()
+            return result
+    
+    def list_all_command(self, active_only: bool = True) -> List[Floor]:
+        with get_session(self.tenant) as session:
+            statement = select(Floor)
+            
+            if active_only:
+                statement = statement.where(Floor.is_active == True)
+            
+            results = session.exec(statement)
+            return results.all()
+    
+    def update_command(self, floor_id: UUID, **kwargs) -> Optional[Floor]:
+        with get_session(self.tenant) as session:
+            db_floor = session.get(Floor, floor_id)
+            if not db_floor:
+                return None
+            
+            for key, value in kwargs.items():
+                if hasattr(db_floor, key):
+                    setattr(db_floor, key, value)
+            
+            session.add(db_floor)
+            session.commit()
+            session.refresh(db_floor)
+            return db_floor
+    
+    def delete_command(self, floor_id: UUID, soft_delete: bool = True) -> bool:
+        with get_session(self.tenant) as session:
+            db_floor = session.get(Floor, floor_id)
+            if not db_floor:
+                return False
+            
+            if soft_delete:
+                db_floor.is_active = False
+                session.add(db_floor)
+            else:
+                session.delete(db_floor)
+            
+            session.commit()
+            return True

healthdatalayer/repositories/infraestructure_repositories/room_repository.py

@@ -0,0 +1,69 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+
+from models import Room
+from config.db import engines, get_session
+
+class RoomRepository:
+    def __init__(self, tenant: str):
+        self.tenant = tenant
+        if tenant not in engines:
+            raise ValueError(f"Tenant {tenant} is not configured")
+    
+    def create_command(self, room: Room) -> Room:
+        with get_session(self.tenant) as session:
+            session.add(room)
+            session.commit()
+            session.refresh(room)
+            return room
+    
+    def get_by_id_command(self, room_id: UUID) -> Optional[Room]:
+        with get_session(self.tenant) as session:
+            return session.get(Room, room_id)
+    
+    def get_by_name_command(self, name: str) -> Optional[Room]:
+        with get_session(self.tenant) as session:
+            statement = select(Room).where(Room.name == name)
+            result = session.exec(statement).first()
+            return result
+    
+    def list_all_command(self, active_only: bool = True) -> List[Room]:
+        with get_session(self.tenant) as session:
+            statement = select(Room)
+            
+            if active_only:
+                statement = statement.where(Room.is_active == True)
+            
+            results = session.exec(statement)
+            return results.all()
+    
+    def update_command(self, room_id: UUID, **kwargs) -> Optional[Room]:
+        with get_session(self.tenant) as session:
+            db_room = session.get(Room, room_id)
+            if not db_room:
+                return None
+            
+            for key, value in kwargs.items():
+                if hasattr(db_room, key):
+                    setattr(db_room, key, value)
+            
+            session.add(db_room)
+            session.commit()
+            session.refresh(db_room)
+            return db_room
+    
+    def delete_command(self, room_id: UUID, soft_delete: bool = True) -> bool:
+        with get_session(self.tenant) as session:
+            db_room = session.get(Room, room_id)
+            if not db_room:
+                return False
+            
+            if soft_delete:
+                db_room.is_active = False
+                session.add(db_room)
+            else:
+                session.delete(db_room)
+            
+            session.commit()
+            return True

healthdatalayer/repositories/infraestructure_repositories/system_repository.py

@@ -0,0 +1,69 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+
+from models import System
+from config.db import engines, get_session
+
+class SystemRepository:
+    def __init__(self, tenant: str):
+        self.tenant = tenant
+        if tenant not in engines:
+            raise ValueError(f"Tenant {tenant} is not configured")
+    
+    def create_command(self, system: System) -> System:
+        with get_session(self.tenant) as session:
+            session.add(system)
+            session.commit()
+            session.refresh(system)
+            return system
+    
+    def get_by_id_command(self, system_id: UUID) -> Optional[System]:
+        with get_session(self.tenant) as session:
+            return session.get(System, system_id)
+    
+    def get_by_name_command(self, name: str) -> Optional[System]:
+        with get_session(self.tenant) as session:
+            statement = select(System).where(System.name == name)
+            result = session.exec(statement).first()
+            return result
+    
+    def list_all_command(self, active_only: bool = True) -> List[System]:
+        with get_session(self.tenant) as session:
+            statement = select(System)
+            
+            if active_only:
+                statement = statement.where(System.is_active == True)
+            
+            results = session.exec(statement)
+            return results.all()
+    
+    def update_command(self, system_id: UUID, **kwargs) -> Optional[System]:
+        with get_session(self.tenant) as session:
+            db_system = session.get(System, system_id)
+            if not db_system:
+                return None
+            
+            for key, value in kwargs.items():
+                if hasattr(db_system, key):
+                    setattr(db_system, key, value)
+            
+            session.add(db_system)
+            session.commit()
+            session.refresh(db_system)
+            return db_system
+    
+    def delete_command(self, system_id: UUID, soft_delete: bool = True) -> bool:
+        with get_session(self.tenant) as session:
+            db_system = session.get(System, system_id)
+            if not db_system:
+                return False
+            
+            if soft_delete:
+                db_system.is_active = False
+                session.add(db_system)
+            else:
+                session.delete(db_system)
+            
+            session.commit()
+            return True

healthdatalayer/repositories/lab_repositories/measure_lab_repository.py

@@ -0,0 +1,80 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+
+from models import MeasureLab
+from config.db import engines, get_session
+
+class MeasureLabRepository:
+    def __init__(self, tenant: str):
+        self.tenant = tenant
+        if tenant not in engines:
+            raise ValueError(f"Tenant {tenant} is not configured")
+
+    def create_command(self, measure_lab: MeasureLab) -> MeasureLab:
+        with get_session(self.tenant) as session:
+            session.add(measure_lab)
+            session.commit()
+            session.refresh(measure_lab)
+            return measure_lab
+
+    def get_by_id_command(self, measure_lab_id: UUID) -> Optional[MeasureLab]:
+        with get_session(self.tenant) as session:
+            return session.get(MeasureLab, measure_lab_id)
+
+    def get_by_name_command(self, name: str) -> Optional[MeasureLab]:
+        with get_session(self.tenant) as session:
+            statement = select(MeasureLab).where(MeasureLab.name == name)
+            return session.exec(statement).first()
+
+    def search_by_name_command(self, name: str) -> List[MeasureLab]:
+        with get_session(self.tenant) as session:
+            statement = select(MeasureLab).where(MeasureLab.name.ilike(f"%{name}%"))
+            results = session.exec(statement)
+            return results.all()
+
+    def list_all_command(self, active_only: bool = True) -> List[MeasureLab]:
+        with get_session(self.tenant) as session:
+            statement = select(MeasureLab)
+            
+            if active_only:
+                statement = statement.where(MeasureLab.is_active == True)
+            
+            results = session.exec(statement)
+            return results.all()
+
+    def update_command(self, measure_lab: MeasureLab) -> MeasureLab:
+        with get_session(self.tenant) as session:
+            db_measure_lab = session.merge(measure_lab)
+            session.commit()
+            session.refresh(db_measure_lab)
+            return db_measure_lab
+
+    def delete_command(self, measure_lab_id: UUID, soft_delete: bool = True) -> bool:
+        with get_session(self.tenant) as session:
+            db_measure_lab = session.get(MeasureLab, measure_lab_id)
+            if not db_measure_lab:
+                return False
+            
+            if soft_delete:
+                db_measure_lab.is_active = False
+                session.add(db_measure_lab)
+            else:
+                session.delete(db_measure_lab)
+            
+            session.commit()
+            return True
+
+    def count_command(self, active_only: bool = True) -> int:
+        with get_session(self.tenant) as session:
+            statement = select(MeasureLab)
+            if active_only:
+                statement = statement.where(MeasureLab.is_active == True)
+            results = session.exec(statement)
+            return len(results.all())
+
+    def exists_by_name_command(self, name: str) -> bool:
+        with get_session(self.tenant) as session:
+            statement = select(MeasureLab).where(MeasureLab.name == name)
+            result = session.exec(statement).first()
+            return result is not None

healthdatalayer/repositories/lab_repositories/medical_lab_repository.py

@@ -0,0 +1,254 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+
+from models import MedicalLab
+from models import Px
+from config.db import engines, get_session
+
+class MedicalLabRepository:
+    def __init__(self, tenant: str):
+        self.tenant = tenant
+        if tenant not in engines:
+            raise ValueError(f"Tenant {tenant} is not configured")
+
+    def create_command(self, medical_lab: MedicalLab) -> MedicalLab:
+        with get_session(self.tenant) as session:
+            session.add(medical_lab)
+            session.commit()
+            session.refresh(medical_lab)
+            return medical_lab
+
+    def get_by_id_command(self, medical_lab_id: UUID, load_relations: bool = False) -> Optional[MedicalLab]:
+        with get_session(self.tenant) as session:
+            medical_lab = session.get(MedicalLab, medical_lab_id)
+            
+            if medical_lab and load_relations:
+                if medical_lab.measure_lab_id:
+                    from models import MeasureLab
+                    measure_lab_obj = session.get(MeasureLab, medical_lab.measure_lab_id)
+                    object.__setattr__(medical_lab, 'measure_lab', measure_lab_obj)
+                
+                from models.lab.client_lab import ClientLab
+                statement = select(ClientLab).where(ClientLab.medical_lab_id == medical_lab_id)
+                client_labs = session.exec(statement).all()
+                
+                pxs_list = []
+                for cl in client_labs:
+                    px = session.get(Px, cl.client_id)
+                    if px:
+                        pxs_list.append(px)
+                
+                object.__setattr__(medical_lab, 'pxs', pxs_list)
+            
+            return medical_lab
+
+    def get_by_parameter_command(self, parameter: str, load_relations: bool = False) -> Optional[MedicalLab]:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalLab).where(MedicalLab.parameter == parameter)
+            medical_lab = session.exec(statement).first()
+            
+            if medical_lab and load_relations:
+                if medical_lab.measure_lab_id:
+                    from models import MeasureLab
+                    measure_lab_obj = session.get(MeasureLab, medical_lab.measure_lab_id)
+                    object.__setattr__(medical_lab, 'measure_lab', measure_lab_obj)
+                
+                from models.lab.client_lab import ClientLab
+                statement_cl = select(ClientLab).where(ClientLab.medical_lab_id == medical_lab.medical_lab_id)
+                client_labs = session.exec(statement_cl).all()
+                
+                pxs_list = []
+                for cl in client_labs:
+                    px = session.get(Px, cl.client_id)
+                    if px:
+                        pxs_list.append(px)
+                
+                object.__setattr__(medical_lab, 'pxs', pxs_list)
+            
+            return medical_lab
+
+    def search_by_parameter_command(self, parameter: str, load_relations: bool = False) -> List[MedicalLab]:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalLab).where(MedicalLab.parameter.ilike(f"%{parameter}%"))
+            results = session.exec(statement).all()
+            
+            if load_relations:
+                from models import MeasureLab
+                from models.lab.client_lab import ClientLab
+                
+                for medical_lab in results:
+                    if medical_lab.measure_lab_id:
+                        measure_lab_obj = session.get(MeasureLab, medical_lab.measure_lab_id)
+                        object.__setattr__(medical_lab, 'measure_lab', measure_lab_obj)
+                    
+                    statement_cl = select(ClientLab).where(ClientLab.medical_lab_id == medical_lab.medical_lab_id)
+                    client_labs = session.exec(statement_cl).all()
+                    
+                    pxs_list = []
+                    for cl in client_labs:
+                        px = session.get(Px, cl.client_id)
+                        if px:
+                            pxs_list.append(px)
+                    
+                    object.__setattr__(medical_lab, 'pxs', pxs_list)
+            
+            return results
+
+    def list_all_command(self, active_only: bool = True, load_relations: bool = False) -> List[MedicalLab]:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalLab)
+            
+            if active_only:
+                statement = statement.where(MedicalLab.is_active == True)
+            
+            results = session.exec(statement).all()
+            
+            if load_relations:
+                from models import MeasureLab
+                from models.lab.client_lab import ClientLab
+                
+                for medical_lab in results:
+                    if medical_lab.measure_lab_id:
+                        measure_lab_obj = session.get(MeasureLab, medical_lab.measure_lab_id)
+                        object.__setattr__(medical_lab, 'measure_lab', measure_lab_obj)
+                    
+                    statement_cl = select(ClientLab).where(ClientLab.medical_lab_id == medical_lab.medical_lab_id)
+                    client_labs = session.exec(statement_cl).all()
+                    
+                    pxs_list = []
+                    for cl in client_labs:
+                        px = session.get(Px, cl.client_id)
+                        if px:
+                            pxs_list.append(px)
+                    
+                    object.__setattr__(medical_lab, 'pxs', pxs_list)
+            
+            return results
+
+    def list_by_measure_lab_command(self, measure_lab_id: UUID, active_only: bool = True) -> List[MedicalLab]:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalLab).where(MedicalLab.measure_lab_id == measure_lab_id)
+            
+            if active_only:
+                statement = statement.where(MedicalLab.is_active == True)
+            
+            results = session.exec(statement)
+            return results.all()
+
+    def update_command(self, medical_lab: MedicalLab) -> MedicalLab:
+        with get_session(self.tenant) as session:
+            db_medical_lab = session.merge(medical_lab)
+            session.commit()
+            session.refresh(db_medical_lab)
+            return db_medical_lab
+
+    def delete_command(self, medical_lab_id: UUID, soft_delete: bool = True) -> bool:
+        with get_session(self.tenant) as session:
+            db_medical_lab = session.get(MedicalLab, medical_lab_id)
+            if not db_medical_lab:
+                return False
+            
+            if soft_delete:
+                db_medical_lab.is_active = False
+                session.add(db_medical_lab)
+            else:
+                session.delete(db_medical_lab)
+            
+            session.commit()
+            return True
+
+    def count_command(self, active_only: bool = True) -> int:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalLab)
+            if active_only:
+                statement = statement.where(MedicalLab.is_active == True)
+            results = session.exec(statement)
+            return len(results.all())
+
+    def exists_by_parameter_command(self, parameter: str) -> bool:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalLab).where(MedicalLab.parameter == parameter)
+            result = session.exec(statement).first()
+            return result is not None
+
+    def get_medical_lab_patients_command(self, medical_lab_id: UUID) -> List[Px]:
+        """Get all patients associated with a medical lab"""
+        with get_session(self.tenant) as session:
+            from models.lab.client_lab import ClientLab
+            
+            statement = select(ClientLab).where(ClientLab.medical_lab_id == medical_lab_id)
+            client_labs = session.exec(statement).all()
+            
+            pxs_list = []
+            for cl in client_labs:
+                px = session.get(Px, cl.client_id)
+                if px:
+                    pxs_list.append(px)
+            
+            return pxs_list
+
+    def assign_patient_command(self, medical_lab_id: UUID, px_id: UUID) -> Optional[MedicalLab]:
+        """Assign a patient to a medical lab"""
+        with get_session(self.tenant) as session:
+            from models.lab.client_lab import ClientLab
+            
+            medical_lab = session.get(MedicalLab, medical_lab_id)
+            if not medical_lab:
+                return None
+            
+            px = session.get(Px, px_id)
+            if not px:
+                return None
+            
+            existing = session.exec(
+                select(ClientLab).where(
+                    ClientLab.medical_lab_id == medical_lab_id,
+                    ClientLab.client_id == px_id
+                )
+            ).first()
+            
+            if not existing:
+                client_lab = ClientLab(medical_lab_id=medical_lab_id, client_id=px_id)
+                session.add(client_lab)
+                session.commit()
+            
+            session.refresh(medical_lab)
+            return medical_lab
+
+    def remove_patient_command(self, medical_lab_id: UUID, px_id: UUID) -> Optional[MedicalLab]:
+        """Remove a patient from a medical lab"""
+        with get_session(self.tenant) as session:
+            from models.lab.client_lab import ClientLab
+            
+            medical_lab = session.get(MedicalLab, medical_lab_id)
+            if not medical_lab:
+                return None
+            
+            client_lab = session.exec(
+                select(ClientLab).where(
+                    ClientLab.medical_lab_id == medical_lab_id,
+                    ClientLab.client_id == px_id
+                )
+            ).first()
+            
+            if client_lab:
+                session.delete(client_lab)
+                session.commit()
+            
+            session.refresh(medical_lab)
+            return medical_lab
+
+    def is_patient_assigned_command(self, medical_lab_id: UUID, px_id: UUID) -> bool:
+        """Check if a patient is assigned to a medical lab"""
+        with get_session(self.tenant) as session:
+            from models.lab.client_lab import ClientLab
+            
+            result = session.exec(
+                select(ClientLab).where(
+                    ClientLab.medical_lab_id == medical_lab_id,
+                    ClientLab.client_id == px_id
+                )
+            ).first()
+            
+            return result is not None