healthdatalayer 1.6.6__py3-none-any.whl

healthdatalayer/repositories/client_repositories/education_repository.py

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

healthdatalayer/repositories/client_repositories/emergency_contact_repository.py

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

healthdatalayer/repositories/client_repositories/gender_repository.py

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

healthdatalayer/repositories/client_repositories/marriage_status_repository.py

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

healthdatalayer/repositories/client_repositories/nationality_repository.py

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

healthdatalayer/repositories/client_repositories/pathological_history_repository.py

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

healthdatalayer/repositories/client_repositories/pet_repository.py

@@ -0,0 +1,126 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+from sqlalchemy.orm import selectinload
+
+from healthdatalayer.models import Pet
+from healthdatalayer.config.db import engines, get_session
+
+class PetRepository:
+    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, pet: Pet) -> Pet:
+        with get_session(self.tenant) as session:
+            session.add(pet)
+            session.commit()
+            session.refresh(pet)
+            return pet
+
+    def get_by_id_command(self, pet_id: UUID, load_relations: bool = False) -> Optional[Pet]:
+        with get_session(self.tenant) as session:
+            if load_relations:
+                statement = (
+                    select(Pet)
+                    .where(Pet.client_id == pet_id)
+                    .options(
+                        selectinload(Pet.gender),
+                        selectinload(Pet.address),
+                        selectinload(Pet.marriage_status),
+                        selectinload(Pet.profession),
+                        selectinload(Pet.education),
+                        selectinload(Pet.user),
+                    )
+                )
+                result = session.exec(statement).first()
+                return result
+            else:
+                return session.get(Pet, pet_id)
+            
+    def get_by_identification_command(self, identification: str, load_relations: bool = False) -> Optional[Pet]:
+        with get_session(self.tenant) as session:
+            statement = select(Pet).where(Pet.identification == identification)
+            
+            if load_relations:
+                statement = statement.options(
+                    selectinload(Pet.gender),
+                    selectinload(Pet.address),
+                    selectinload(Pet.marriage_status),
+                    selectinload(Pet.profession),
+                    selectinload(Pet.education),
+                    selectinload(Pet.user),
+                )
+            
+            result = session.exec(statement).first()
+            return result
+            
+    def search_by_name_command(self, name: str, load_relations: bool = False) -> List[Pet]:
+        with get_session(self.tenant) as session:
+            statement = select(Pet).where(
+                (Pet.first_name.ilike(f"%{name}%")) | 
+                (Pet.last_name.ilike(f"%{name}%"))
+            )
+            
+            if load_relations:
+                statement = statement.options(
+                    selectinload(Pet.gender),
+                    selectinload(Pet.address),
+                    selectinload(Pet.marriage_status),
+                    selectinload(Pet.profession),
+                    selectinload(Pet.education),
+                    selectinload(Pet.user),
+                )
+            
+            results = session.exec(statement)
+            return results.all()
+    
+    def list_all_command(self, active_only: bool = True, load_relations: bool = False) -> List[Pet]:
+        with get_session(self.tenant) as session:
+            statement = select(Pet)
+            
+            if active_only:
+                statement = statement.where(Pet.is_active == True)
+            
+            if load_relations:
+                statement = statement.options(
+                    selectinload(Pet.gender),
+                    selectinload(Pet.address),
+                    selectinload(Pet.marriage_status),
+                    selectinload(Pet.profession),
+                    selectinload(Pet.education),
+                )
+            
+            results = session.exec(statement)
+            return results.all()
+            
+    def update_command(self, pet: Pet) -> Pet:
+        with get_session(self.tenant) as session:
+            db_pet = session.merge(pet)
+            session.commit()
+            session.refresh(db_pet)
+            return db_pet
+
+    def delete_command(self, pet_id: UUID, soft_delete: bool = True) -> bool:
+        with get_session(self.tenant) as session:
+            db_pet = session.get(Pet, pet_id)
+            if not db_pet:
+                return False
+            
+            if soft_delete:
+                db_pet.is_active = False
+                session.add(db_pet)
+            else:
+                session.delete(db_pet)
+            
+            session.commit()
+            return True
+    
+    def count_command(self, active_only: bool = True) -> int:
+        with get_session(self.tenant) as session:
+            statement = select(Pet)
+            if active_only:
+                statement = statement.where(Pet.is_active == True)
+            results = session.exec(statement)
+            return len(results.all())

healthdatalayer/repositories/client_repositories/profession_repository.py

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