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

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

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

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

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

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

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