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

healthdatalayer/repositories/medical_visit_repositories/medical_diagnosis_repository.py

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

healthdatalayer/repositories/medical_visit_repositories/medical_diagnosis_visit_repository.py

@@ -0,0 +1,92 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select, or_
+from sqlalchemy.orm import selectinload,joinedload
+from models import MedicalDiagnosisVisit
+from models import MedicalVisit
+from config.db import engines, get_session
+
+class MedicalDiagnosisVisitRepository:
+    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_diagnosis_visit: MedicalDiagnosisVisit) -> MedicalDiagnosisVisit:
+        with get_session(self.tenant) as session:
+            session.add(medical_diagnosis_visit)
+            session.commit()
+            session.refresh(medical_diagnosis_visit)
+            return medical_diagnosis_visit
+    
+    def get_by_id_command(self, medical_diagnosis_visit_id: UUID, load_relations: bool = False) -> Optional[MedicalDiagnosisVisit]:
+        with get_session(self.tenant) as session:
+            
+            if load_relations:
+                statement = select(MedicalDiagnosisVisit).where(MedicalDiagnosisVisit.medical_diagnosis_visit_id == medical_diagnosis_visit_id).options(
+                    joinedload(MedicalDiagnosisVisit.medical_visit),
+                    joinedload(MedicalDiagnosisVisit.medical_diagnosis)
+                )
+                medical_diagnosis_visit = session.exec(statement).first()
+               
+                return medical_diagnosis_visit
+            else:
+                return session.get(MedicalDiagnosisVisit, medical_diagnosis_visit_id)
+    
+    def get_by_medical_visit_id_command(self, medical_visit_id: UUID, load_relations: bool = False) ->Optional[MedicalDiagnosisVisit]:
+        with get_session(self.tenant) as session:
+            
+            statement = select(MedicalDiagnosisVisit).where(MedicalDiagnosisVisit.medical_visit_id == medical_visit_id)
+            if load_relations:
+                statement = statement.options(
+                    joinedload(MedicalDiagnosisVisit.medical_visit),
+                    joinedload(MedicalDiagnosisVisit.medical_diagnosis)
+                )
+            medical_diagnosis_visit = session.exec(statement).first()
+            
+            return medical_diagnosis_visit
+    
+    def get_all_command(self, active_only: bool = True,load_related: bool = False) -> List[MedicalDiagnosisVisit]:
+        with get_session(self.tenant) as session:
+            
+            statement = select(MedicalDiagnosisVisit)
+            
+            if load_related:
+                statement = select(MedicalDiagnosisVisit).options(
+                    selectinload(MedicalDiagnosisVisit.medical_visit),
+                    joinedload(MedicalDiagnosisVisit.medical_diagnosis)
+                )
+            
+            if active_only:
+                statement = statement.where(MedicalDiagnosisVisit.is_active == True)
+                medical_diagnosis_visit = session.exec(statement).all()
+                
+            return medical_diagnosis_visit
+        
+    def update_command(self, medical_diagnosis_visit: MedicalDiagnosisVisit) -> MedicalDiagnosisVisit:
+        with get_session(self.tenant) as session:
+            existing_medical_diagnosis_visit = session.get(MedicalDiagnosisVisit, medical_diagnosis_visit.medical_diagnosis_visit_id)
+            if not existing_medical_diagnosis_visit:
+                raise ValueError(f"MedicalDiagnosisVisit with id {medical_diagnosis_visit.medical_diagnosis_visit_id} does not exist")
+            
+            for key, value in medical_diagnosis_visit.dict(exclude_unset=True).items():
+                setattr(existing_medical_diagnosis_visit, key, value)
+            
+            bd_medical_diagnosis_visit =  session.merge(existing_medical_diagnosis_visit)
+            session.commit()
+            session.refresh(bd_medical_diagnosis_visit)
+            return bd_medical_diagnosis_visit
+        
+    def delete_command(self, medical_diagnosis_visit_id: UUID, soft_delete: bool = False)->None:
+        with get_session(self.tenant) as session:
+            existing_medical_diagnosis_visit = session.get(MedicalVisit, medical_diagnosis_visit_id)
+            if not existing_medical_diagnosis_visit:
+                raise ValueError(f"MedicalDiagnosisVisit with id {medical_diagnosis_visit_id} does not exist")
+
+            if soft_delete:
+                existing_medical_diagnosis_visit.is_active = False
+                session.add(existing_medical_diagnosis_visit)
+            else:
+                session.delete(existing_medical_diagnosis_visit)
+
+            session.commit() 

healthdatalayer/repositories/medical_visit_repositories/medical_drug_recipe_repository.py

@@ -0,0 +1,70 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+from sqlalchemy.orm import selectinload,joinedload
+from models import MedicalDrugRecipe
+from config.db import engines, get_session
+
+class MedicalDrugRecipeRepository:
+    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_drug_recipe: MedicalDrugRecipe) -> MedicalDrugRecipe:
+        with get_session(self.tenant) as session:
+            session.add(medical_drug_recipe)
+            session.commit()
+            session.refresh(medical_drug_recipe)
+            return medical_drug_recipe
+
+    def get_by_id_command(self, medical_drug_recipe_id: UUID) -> Optional[MedicalDrugRecipe]:
+        with get_session(self.tenant) as session:
+            
+            return session.get(MedicalDrugRecipe, medical_drug_recipe_id)
+        
+    def list_all_command(self, active_only: bool = True)->List[MedicalDrugRecipe]:
+        with get_session(self.tenant) as session:
+            
+            statement = select(MedicalDrugRecipe)
+            if active_only:
+                statement = statement.where(MedicalDrugRecipe.is_active == True)
+                
+            return session.exec(statement).all()
+    
+    def get_by_medical_recipe_visit_id_command(self, medical_recipe_visit_id: UUID,active_only: bool = True)-> List[MedicalDrugRecipe]:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalDrugRecipe).where(MedicalDrugRecipe.medical_recipe_visit_id == medical_recipe_visit_id)
+            if active_only:
+                statement = statement.where(MedicalDrugRecipe.is_active == True)
+                
+            return session.exec(statement).all()
+    
+    def update_command(self, medical_drug_recipe_id: UUID, **kwargs) -> Optional[MedicalDrugRecipe]:
+        with get_session(self.tenant) as session:
+            db_medical_drug_recipe = session.get(MedicalDrugRecipe, medical_drug_recipe_id)
+            if not db_medical_drug_recipe:
+                return None
+            
+            for key, value in kwargs.items():
+                if hasattr(db_medical_drug_recipe, key):
+                    setattr(db_medical_drug_recipe, key, value)
+            
+            session.add(db_medical_drug_recipe)
+            session.commit()
+            session.refresh(db_medical_drug_recipe)
+            return db_medical_drug_recipe
+    
+    def delete_command(self, medical_drug_recipe_id: UUID, soft_delete: bool = True) -> bool:
+        with get_session(self.tenant) as session:
+            db_medical_drug_recipe = session.get(MedicalDrugRecipe, medical_drug_recipe_id)
+            if not db_medical_drug_recipe:
+                return False
+            
+            if soft_delete:
+                db_medical_drug_recipe.is_active = False
+                session.add(db_medical_drug_recipe)
+            else:
+                session.delete(db_medical_drug_recipe)
+            
+            session.commit()
+            return True

healthdatalayer/repositories/medical_visit_repositories/medical_drug_repository.py

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

healthdatalayer/repositories/medical_visit_repositories/medical_recipe_visit_repository.py

@@ -0,0 +1,93 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select, or_
+from sqlalchemy.orm import selectinload,joinedload
+from models import MedicalRecipeVisit
+from config.db import engines, get_session
+
+class MedicalRecipeVisitRepository:
+    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_recipe_visit: MedicalRecipeVisit) -> MedicalRecipeVisit:
+        with get_session(self.tenant) as session:
+            session.add(medical_recipe_visit)
+            session.commit()
+            session.refresh(medical_recipe_visit)
+            return medical_recipe_visit
+    
+    def get_by_id_command(self, medical_recipe_visit_id: UUID, load_relations: bool = False) -> Optional[MedicalRecipeVisit]:
+        with get_session(self.tenant) as session:
+            
+            if load_relations:
+                statement = select(MedicalRecipeVisit).where(MedicalRecipeVisit.medical_recipe_visit_id == medical_recipe_visit_id).options(
+                    joinedload(MedicalRecipeVisit.medical_visit),
+                    joinedload(MedicalRecipeVisit.medical_drugs)
+                )
+                medical_recipe_visit = session.exec(statement).first()
+               
+                return medical_recipe_visit
+            else:
+                return session.get(MedicalRecipeVisit, medical_recipe_visit_id)
+    
+    def get_by_medical_visit_id_command(self, medical_visit_id: UUID, load_relations: bool = False) -> Optional[MedicalRecipeVisit]:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalRecipeVisit).where(MedicalRecipeVisit.medical_visit_id == medical_visit_id)
+            if load_relations:
+                statement = statement.options(
+                    selectinload(MedicalRecipeVisit.medical_visit),
+                    selectinload(MedicalRecipeVisit.medical_drugs)
+                )
+            medical_recipe_visit = session.exec(statement).first()
+               
+            return medical_recipe_visit
+            
+    def list_all_command(self, active_only: bool = True, load_relations: bool = False)->List[MedicalRecipeVisit]:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalRecipeVisit)
+            
+            if load_relations:
+                
+                statement = select(MedicalRecipeVisit).options(
+                    selectinload(MedicalRecipeVisit.medical_visit),
+                    selectinload(MedicalRecipeVisit.medical_drugs)
+                )
+                if active_only:
+                    statement = statement.where(MedicalRecipeVisit.is_active == True)
+                medical_recipe_visit = session.exec(statement).all()
+              
+                return medical_recipe_visit
+            
+            statement = select(MedicalRecipeVisit)
+            return session.exec(statement).all()
+    
+    def update_command(self, medical_recipe_visit: MedicalRecipeVisit) -> MedicalRecipeVisit:
+        with get_session(self.tenant) as session:
+            existing_medical_recipe_visit = session.get(MedicalRecipeVisit, medical_recipe_visit.medical_recipe_visit_id)
+            if not existing_medical_recipe_visit:
+                raise ValueError(f"medical_recipe_visit with id {medical_recipe_visit.medical_recipe_visit_id} does not exist")
+            
+            for key, value in medical_recipe_visit.dict(exclude_unset=True).items():
+                setattr(existing_medical_recipe_visit, key, value)
+            
+            bd_medical_recipe_visit =  session.merge(existing_medical_recipe_visit)
+            session.commit()
+            session.refresh(bd_medical_recipe_visit)
+            return bd_medical_recipe_visit
+        
+    def delete_command(self, medical_recipe_visit_id: UUID, soft_delete: bool = False)->None:
+        with get_session(self.tenant) as session:
+            existing_medical_recipe_visit = session.get(MedicalRecipeVisit, medical_recipe_visit_id)
+            if not existing_medical_recipe_visit:
+                raise ValueError(f"MedicalRecipeVisit with id {medical_recipe_visit_id} does not exist")
+
+            if soft_delete:
+                existing_medical_recipe_visit.is_active = False
+                session.add(existing_medical_recipe_visit)
+            else:
+                session.delete(existing_medical_recipe_visit)
+
+            session.commit()
+    

healthdatalayer/repositories/medical_visit_repositories/medical_visit_repository.py

@@ -0,0 +1,110 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select, or_
+from sqlalchemy.orm import selectinload,joinedload
+from models import MedicalVisit
+from config.db import engines, get_session
+
+class MedicalVisitRepository:
+    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_visit: MedicalVisit) -> MedicalVisit:
+        with get_session(self.tenant) as session:
+            session.add(medical_visit)
+            session.commit()
+            session.refresh(medical_visit)
+            return medical_visit
+    
+    def get_by_id_command(self, medical_visit_id: UUID, load_relations: bool = False) -> Optional[MedicalVisit]:
+        with get_session(self.tenant) as session:
+            
+            if load_relations:
+                statement = select(MedicalVisit).where(MedicalVisit.medical_visit_id == medical_visit_id).options(
+                    joinedload(MedicalVisit.client),
+                    joinedload(MedicalVisit.collaborator),
+                    joinedload(MedicalVisit.speciality),
+                    selectinload(MedicalVisit.medical_diagnosis_visits),
+                    selectinload(MedicalVisit.medical_recipe_visits),
+                    selectinload(MedicalVisit.organ_system_reviews),
+                    selectinload(MedicalVisit.physical_exams)
+                )
+                medical_visit = session.exec(statement).first()
+               
+                return medical_visit
+            else:
+                return session.get(MedicalVisit, medical_visit_id)
+    
+    def list_all_command(self, active_only: bool = True, load_relations: bool = False)->List[MedicalVisit]:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalVisit)
+            
+            if load_relations:
+                
+                statement = select(MedicalVisit).options(
+                    joinedload(MedicalVisit.client),
+                    joinedload(MedicalVisit.collaborator),
+                    joinedload(MedicalVisit.speciality),
+                    selectinload(MedicalVisit.medical_diagnosis_visits),
+                    selectinload(MedicalVisit.medical_recipe_visits),
+                    selectinload(MedicalVisit.organ_system_reviews),
+                    selectinload(MedicalVisit.physical_exams)
+                )
+                if active_only:
+                    statement = statement.where(MedicalVisit.is_active == True)
+                medical_visits = session.exec(statement).all()
+              
+                return medical_visits
+            
+            statement = select(MedicalVisit)
+            return session.exec(statement).all()
+    
+    def get_by_client_id_command(self, client_id: UUID, active_only: bool = True, load_relations: bool = False) -> List[MedicalVisit]:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalVisit).where(MedicalVisit.client_id == client_id)
+            if active_only:
+                statement = statement.where(MedicalVisit.is_active == True)
+            if load_relations:
+                statement = statement.options(
+                    joinedload(MedicalVisit.client),
+                    joinedload(MedicalVisit.collaborator),
+                    joinedload(MedicalVisit.speciality),
+                    selectinload(MedicalVisit.medical_diagnosis_visits),
+                    selectinload(MedicalVisit.medical_recipe_visits),
+                    selectinload(MedicalVisit.organ_system_reviews),
+                    selectinload(MedicalVisit.physical_exams)
+                )
+            
+            medical_visits = session.exec(statement).all()
+            return medical_visits
+    
+    def update_command(self, medical_visit: MedicalVisit) -> MedicalVisit:
+        with get_session(self.tenant) as session:
+            existing_medical_visit = session.get(MedicalVisit, medical_visit.medical_visit_id)
+            if not existing_medical_visit:
+                raise ValueError(f"medical_visit with id {medical_visit.medical_visit_id} does not exist")
+            
+            for key, value in medical_visit.dict(exclude_unset=True).items():
+                setattr(existing_medical_visit, key, value)
+            
+            bd_medical_visit =  session.merge(existing_medical_visit)
+            session.commit()
+            session.refresh(bd_medical_visit)
+            return bd_medical_visit
+        
+    def delete_command(self, medical_visit_id: UUID, soft_delete: bool = False)->None:
+        with get_session(self.tenant) as session:
+            existing_bridge = session.get(MedicalVisit, medical_visit_id)
+            if not existing_bridge:
+                raise ValueError(f"MedicalVisit with id {medical_visit_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/medical_visit_repositories/organ_system_review_repository.py

@@ -0,0 +1,89 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select, or_
+from sqlalchemy.orm import selectinload,joinedload
+from models import OrganSystemReview
+from models import MedicalVisit
+from config.db import engines, get_session
+
+class OrganSystemReviewRepository:
+    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, organ_system_review: OrganSystemReview) -> OrganSystemReview:
+        with get_session(self.tenant) as session:
+            session.add(organ_system_review)
+            session.commit()
+            session.refresh(organ_system_review)
+            return organ_system_review
+    
+    def get_by_id_command(self, organ_system_review_id: UUID, load_relations: bool = False) -> Optional[OrganSystemReview]:
+        with get_session(self.tenant) as session:
+            
+            if load_relations:
+                statement = select(OrganSystemReview).where(OrganSystemReview.organ_system_review_id == organ_system_review_id).options(
+                    joinedload(OrganSystemReview.medical_visit)
+                )
+                organ_system_review = session.exec(statement).first()
+               
+                return organ_system_review
+            else:
+                return session.get(OrganSystemReview, organ_system_review_id)
+    
+    def get_by_medical_visit_id_command(self, medical_visit_id: UUID, load_relations: bool = False) ->Optional[OrganSystemReview]:
+        with get_session(self.tenant) as session:
+            
+            statement = select(OrganSystemReview).where(OrganSystemReview.medical_visit_id == medical_visit_id)
+            if load_relations:
+                statement = statement.options(
+                    joinedload(OrganSystemReview.medical_visit)
+                )
+            organ_system_review = session.exec(statement).first()
+            
+            return organ_system_review 
+    
+    def get_all_command(self, active_only: bool = True,load_related: bool = False) -> List[OrganSystemReview]:
+        with get_session(self.tenant) as session:
+            
+            statement = select(OrganSystemReview)
+            
+            if load_related:
+                statement = select(OrganSystemReview).options(
+                    selectinload(OrganSystemReview.medical_visit)
+                )
+            
+            if active_only:
+                statement = statement.where(OrganSystemReview.is_active == True)
+                organ_system_review = session.exec(statement).all()
+                
+            return organ_system_review
+        
+    def update_command(self, organ_system_review: OrganSystemReview) -> OrganSystemReview:
+        with get_session(self.tenant) as session:
+            existing_organ_system_review = session.get(OrganSystemReview, organ_system_review.organ_system_review_id)
+            if not existing_organ_system_review:
+                raise ValueError(f"triage with id {organ_system_review.organ_system_review_id} does not exist")
+            
+            for key, value in organ_system_review.dict(exclude_unset=True).items():
+                setattr(existing_organ_system_review, key, value)
+            
+            bd_organ_system_review =  session.merge(existing_organ_system_review)
+            session.commit()
+            session.refresh(bd_organ_system_review)
+            return bd_organ_system_review
+        
+    def delete_command(self, organ_system_review_id: UUID, soft_delete: bool = False)->None:
+        with get_session(self.tenant) as session:
+            existing_organ_system_review = session.get(MedicalVisit, organ_system_review_id)
+            if not existing_organ_system_review:
+                raise ValueError(f"MedicalVisit with id {organ_system_review_id} does not exist")
+
+            if soft_delete:
+                existing_organ_system_review.is_active = False
+                session.add(existing_organ_system_review)
+            else:
+                session.delete(existing_organ_system_review)
+
+            session.commit()

healthdatalayer/repositories/medical_visit_repositories/physical_exam_repository.py

@@ -0,0 +1,89 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select, or_
+from sqlalchemy.orm import selectinload,joinedload
+from models import PhysicalExam
+from models import MedicalVisit
+from config.db import engines, get_session
+
+class PhysicalExamRepository:
+    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, physical_exam: PhysicalExam) -> PhysicalExam:
+        with get_session(self.tenant) as session:
+            session.add(physical_exam)
+            session.commit()
+            session.refresh(physical_exam)
+            return physical_exam
+    
+    def get_by_id_command(self, physical_exam_id: UUID, load_relations: bool = False) -> Optional[PhysicalExam]:
+        with get_session(self.tenant) as session:
+            
+            if load_relations:
+                statement = select(PhysicalExam).where(PhysicalExam.physical_exam_id == physical_exam_id).options(
+                    joinedload(PhysicalExam.medical_visit)
+                )
+                physical_exam = session.exec(statement).first()
+               
+                return physical_exam
+            else:
+                return session.get(PhysicalExam, physical_exam_id)
+    
+    def get_by_medical_visit_id_command(self, medical_visit_id: UUID, load_relations: bool = False) ->Optional[PhysicalExam]:
+        with get_session(self.tenant) as session:
+            
+            statement = select(PhysicalExam).where(PhysicalExam.medical_visit_id == medical_visit_id)
+            if load_relations:
+                statement = statement.options(
+                    joinedload(PhysicalExam.medical_visit)
+                )
+            physical_exam = session.exec(statement).first()
+            
+            return physical_exam 
+    
+    def get_all_command(self, active_only: bool = True,load_related: bool = False) -> List[PhysicalExam]:
+        with get_session(self.tenant) as session:
+            
+            statement = select(PhysicalExam)
+            
+            if load_related:
+                statement = select(PhysicalExam).options(
+                    selectinload(PhysicalExam.medical_visit)
+                )
+            
+            if active_only:
+                statement = statement.where(PhysicalExam.is_active == True)
+                physical_exam = session.exec(statement).all()
+                
+            return physical_exam
+        
+    def update_command(self, physical_exam: PhysicalExam) -> PhysicalExam:
+        with get_session(self.tenant) as session:
+            existing_physical_exam = session.get(PhysicalExam, physical_exam.physical_exam_id)
+            if not existing_physical_exam:
+                raise ValueError(f"triage with id {physical_exam.physical_exam_id} does not exist")
+            
+            for key, value in physical_exam.dict(exclude_unset=True).items():
+                setattr(existing_physical_exam, key, value)
+            
+            bd_physical_exam =  session.merge(existing_physical_exam)
+            session.commit()
+            session.refresh(bd_physical_exam)
+            return bd_physical_exam
+        
+    def delete_command(self, physical_exam_id: UUID, soft_delete: bool = False)->None:
+        with get_session(self.tenant) as session:
+            existing_physical_exam = session.get(MedicalVisit, physical_exam_id)
+            if not existing_physical_exam:
+                raise ValueError(f"MedicalVisit with id {physical_exam_id} does not exist")
+
+            if soft_delete:
+                existing_physical_exam.is_active = False
+                session.add(existing_physical_exam)
+            else:
+                session.delete(existing_physical_exam)
+
+            session.commit()