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

repositories/collaborator_repositories/speciality_repository.py

@@ -0,0 +1,75 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+
+from models import Speciality
+from config.db import engines, get_session
+
+class SpecialityRepository:
+    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, speciality : Speciality) -> Speciality:
+        with get_session(self.tenant) as session:
+            session.add(speciality)
+            session.commit()
+            session.refresh(speciality)
+            return speciality
+    
+    def get_by_id_command(self, speciality_id: UUID) -> Optional[Speciality]:
+        with get_session(self.tenant) as session:
+            return session.get(Speciality, speciality_id)
+    
+    def get_by_name_command(self, name: str) -> Optional[Speciality]:
+        with get_session(self.tenant) as session:
+            statement = select(Speciality).where(Speciality.name == name)
+            result = session.exec(statement).first()
+            return result
+    
+    def get_by_subspeciality_command(self, subspeciality: str) -> Optional[List[Speciality]]:
+        with get_session(self.tenant) as session:
+            statement = select(Speciality).where(Speciality.subspeciality == subspeciality)
+            result = session.exec(statement).first()
+            return result
+    
+    def list_all_command(self, active_only: bool = True) -> List[Speciality]:
+        with get_session(self.tenant) as session:
+            statement = select(Speciality)
+            
+            if active_only:
+                statement = statement.where(Speciality.is_active == True)
+            
+            results = session.exec(statement)
+            return results.all()
+    
+    def update_command(self, speciality_id: UUID, **kwargs) -> Optional[Speciality]:
+        with get_session(self.tenant) as session:
+            db_speciality = session.get(Speciality, speciality_id)
+            if not db_speciality:
+                return None
+            
+            for key, value in kwargs.items():
+                if hasattr(db_speciality, key):
+                    setattr(db_speciality, key, value)
+            
+            session.add(db_speciality)
+            session.commit()
+            session.refresh(db_speciality)
+            return db_speciality
+    
+    def delete_command(self, speciality_id: UUID, soft_delete: bool = True) -> bool:
+        with get_session(self.tenant) as session:
+            db_speciality = session.get(Speciality, speciality_id)
+            if not db_speciality:
+                return False
+            
+            if soft_delete:
+                db_speciality.is_active = False
+                session.add(db_speciality)
+            else:
+                session.delete(db_speciality)
+            
+            session.commit()
+            return True

repositories/infraestructure_repositories/area_repository.py

@@ -0,0 +1,69 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+
+from models import Area
+from config.db import engines, get_session
+
+class AreaRepository:
+    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, area: Area) -> Area:
+        with get_session(self.tenant) as session:
+            session.add(area)
+            session.commit()
+            session.refresh(area)
+            return area
+    
+    def get_by_id_command(self, area_id: UUID) -> Optional[Area]:
+        with get_session(self.tenant) as session:
+            return session.get(Area, area_id)
+    
+    def get_by_name_command(self, name: str) -> Optional[Area]:
+        with get_session(self.tenant) as session:
+            statement = select(Area).where(Area.name == name)
+            result = session.exec(statement).first()
+            return result
+    
+    def list_all_command(self, active_only: bool = True) -> List[Area]:
+        with get_session(self.tenant) as session:
+            statement = select(Area)
+            
+            if active_only:
+                statement = statement.where(Area.is_active == True)
+            
+            results = session.exec(statement)
+            return results.all()
+    
+    def update_command(self, area_id: UUID, **kwargs) -> Optional[Area]:
+        with get_session(self.tenant) as session:
+            db_area = session.get(Area, area_id)
+            if not db_area:
+                return None
+            
+            for key, value in kwargs.items():
+                if hasattr(db_area, key):
+                    setattr(db_area, key, value)
+            
+            session.add(db_area)
+            session.commit()
+            session.refresh(db_area)
+            return db_area
+    
+    def delete_command(self, area_id: UUID, soft_delete: bool = True) -> bool:
+        with get_session(self.tenant) as session:
+            db_area = session.get(Area, area_id)
+            if not db_area:
+                return False
+            
+            if soft_delete:
+                db_area.is_active = False
+                session.add(db_area)
+            else:
+                session.delete(db_area)
+            
+            session.commit()
+            return True

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

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()

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

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

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

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