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

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 models import Pet
+from 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())

repositories/client_repositories/profession_repository.py

@@ -0,0 +1,70 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+
+from models import Profession
+from 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

repositories/client_repositories/px_repository.py

@@ -0,0 +1,210 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+
+from models import Px
+from config.db import engines, get_session
+
+class PxRepository:
+    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, px: Px) -> Px:
+        with get_session(self.tenant) as session:
+            session.add(px)
+            session.commit()
+            session.refresh(px)
+            return px
+
+    def get_by_id_command(self, px_id: UUID, load_relations: bool = False) -> Optional[Px]:
+        with get_session(self.tenant) as session:
+            px = session.get(Px, px_id)
+            
+            if px and load_relations:
+                if px.gender_id:
+                    from models.client.gender import Gender
+                    gender_obj = session.get(Gender, px.gender_id)
+                    object.__setattr__(px, 'gender', gender_obj)
+                
+                if px.address_id:
+                    from models.client.address import Address
+                    address_obj = session.get(Address, px.address_id)
+                    object.__setattr__(px, 'address', address_obj)
+                
+                if px.marriage_status_id:
+                    from models.client.marriage_status import MarriageStatus
+                    marriage_status_obj = session.get(MarriageStatus, px.marriage_status_id)
+                    object.__setattr__(px, 'marriage_status', marriage_status_obj)
+                
+                if px.profession_id:
+                    from models.client.profession import Profession
+                    profession_obj = session.get(Profession, px.profession_id)
+                    object.__setattr__(px, 'profession', profession_obj)
+                
+                if px.education_id:
+                    from models.client.education import Education
+                    education_obj = session.get(Education, px.education_id)
+                    object.__setattr__(px, 'education', education_obj)
+                
+                if px.user_id:
+                    from models.user.user import User
+                    user_obj = session.get(User, px.user_id)
+                    object.__setattr__(px, 'user', user_obj)
+            
+            return px
+            
+    def get_by_identification_command(self, identification: str, load_relations: bool = False) -> Optional[Px]:
+        with get_session(self.tenant) as session:
+            statement = select(Px).where(Px.identification == identification)
+            px = session.exec(statement).first()
+            
+            if px and load_relations:
+                if px.gender_id:
+                    from models.client.gender import Gender
+                    gender_obj = session.get(Gender, px.gender_id)
+                    object.__setattr__(px, 'gender', gender_obj)
+                
+                if px.address_id:
+                    from models.client.address import Address
+                    address_obj = session.get(Address, px.address_id)
+                    object.__setattr__(px, 'address', address_obj)
+                
+                if px.marriage_status_id:
+                    from models.client.marriage_status import MarriageStatus
+                    marriage_status_obj = session.get(MarriageStatus, px.marriage_status_id)
+                    object.__setattr__(px, 'marriage_status', marriage_status_obj)
+                
+                if px.profession_id:
+                    from models.client.profession import Profession
+                    profession_obj = session.get(Profession, px.profession_id)
+                    object.__setattr__(px, 'profession', profession_obj)
+                
+                if px.education_id:
+                    from models.client.education import Education
+                    education_obj = session.get(Education, px.education_id)
+                    object.__setattr__(px, 'education', education_obj)
+                
+                if px.user_id:
+                    from models.user.user import User
+                    user_obj = session.get(User, px.user_id)
+                    object.__setattr__(px, 'user', user_obj)
+            
+            return px
+            
+    def search_by_name_command(self, name: str, load_relations: bool = False) -> List[Px]:
+        with get_session(self.tenant) as session:
+            statement = select(Px).where(
+                (Px.first_name.ilike(f"%{name}%")) | 
+                (Px.last_name.ilike(f"%{name}%"))
+            )
+            
+            results = session.exec(statement).all()
+            
+            if load_relations:
+                for px in results:
+                    if px.gender_id:
+                        from models.client.gender import Gender
+                        gender_obj = session.get(Gender, px.gender_id)
+                        object.__setattr__(px, 'gender', gender_obj)
+                    
+                    if px.address_id:
+                        from models.client.address import Address
+                        address_obj = session.get(Address, px.address_id)
+                        object.__setattr__(px, 'address', address_obj)
+                    
+                    if px.marriage_status_id:
+                        from models.client.marriage_status import MarriageStatus
+                        marriage_status_obj = session.get(MarriageStatus, px.marriage_status_id)
+                        object.__setattr__(px, 'marriage_status', marriage_status_obj)
+                    
+                    if px.profession_id:
+                        from models.client.profession import Profession
+                        profession_obj = session.get(Profession, px.profession_id)
+                        object.__setattr__(px, 'profession', profession_obj)
+                    
+                    if px.education_id:
+                        from models.client.education import Education
+                        education_obj = session.get(Education, px.education_id)
+                        object.__setattr__(px, 'education', education_obj)
+                    
+                    if px.user_id:
+                        from models.user.user import User
+                        user_obj = session.get(User, px.user_id)
+                        object.__setattr__(px, 'user', user_obj)
+            
+            return results
+    
+    def list_all_command(self, active_only: bool = True, load_relations: bool = False) -> List[Px]:
+        with get_session(self.tenant) as session:
+            statement = select(Px)
+            
+            if active_only:
+                statement = statement.where(Px.is_active == True)
+            
+            results = session.exec(statement).all()
+            
+            if load_relations:
+                for px in results:
+                    if px.gender_id:
+                        from models.client.gender import Gender
+                        gender_obj = session.get(Gender, px.gender_id)
+                        object.__setattr__(px, 'gender', gender_obj)
+                    
+                    if px.address_id:
+                        from models.client.address import Address
+                        address_obj = session.get(Address, px.address_id)
+                        object.__setattr__(px, 'address', address_obj)
+                    
+                    if px.marriage_status_id:
+                        from models.client.marriage_status import MarriageStatus
+                        marriage_status_obj = session.get(MarriageStatus, px.marriage_status_id)
+                        object.__setattr__(px, 'marriage_status', marriage_status_obj)
+                    
+                    if px.profession_id:
+                        from models.client.profession import Profession
+                        profession_obj = session.get(Profession, px.profession_id)
+                        object.__setattr__(px, 'profession', profession_obj)
+                    
+                    if px.education_id:
+                        from models.client.education import Education
+                        education_obj = session.get(Education, px.education_id)
+                        object.__setattr__(px, 'education', education_obj)
+                    
+                    if px.user_id:
+                        from models.user.user import User
+                        user_obj = session.get(User, px.user_id)
+                        object.__setattr__(px, 'user', user_obj)
+            
+            return results
+            
+    def update_command(self, px: Px) -> Px:
+        with get_session(self.tenant) as session:
+            db_px = session.merge(px)
+            session.commit()
+            session.refresh(db_px)
+            return db_px
+
+    def delete_command(self, px_id: UUID, soft_delete: bool = True) -> bool:
+        with get_session(self.tenant) as session:
+            db_px = session.get(Px, px_id)
+            if not db_px:
+                return False
+            
+            if soft_delete:
+                db_px.is_active = False
+                session.add(db_px)
+            else:
+                session.delete(db_px)
+            
+            session.commit()
+            return True
+    
+    def count_command(self, active_only: bool = True) -> int:
+        with get_session(self.tenant) as session:
+            statement = select(Px)
+            if active_only:
+                statement = statement.where(Px.is_active == True)
+            results = session.exec(statement)
+            return len(results.all())

repositories/collaborator_repositories/collaborator_repository.py

@@ -0,0 +1,150 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select, or_
+from sqlalchemy.orm import selectinload,joinedload
+from models import Collaborator
+from models import Speciality
+from config.db import engines, get_session
+
+class CollaboratorRepository:
+    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, collaborator: Collaborator) -> Collaborator:
+        with get_session(self.tenant) as session:
+            session.add(collaborator)
+            session.commit()
+            session.refresh(collaborator)
+            return collaborator
+        
+    def get_by_id_command(self, collaborator_id: UUID, load_relations: bool = False) -> Optional[Collaborator]:
+        with get_session(self.tenant) as session:
+            if load_relations:
+                statement = select(Collaborator).where(Collaborator.collaborator_id == collaborator_id).options(
+                    selectinload(Collaborator.specialties)
+                )
+                collaborator = session.exec(statement).first()
+                if load_relations:
+                    
+                    if collaborator.collaborator_type_id:
+                        from models.collaborator.collaborator_type import CollaboratorType
+                        collab_type_obj = session.get(CollaboratorType, collaborator.collaborator_type_id)
+                        object.__setattr__(collaborator,'collaborator_type', collab_type_obj)
+                        
+                    if collaborator.user_id:
+                        from models.user.user import User
+                        user_obj = session.get(User, collaborator.user_id)
+                        object.__setattr__(collaborator,'user',user_obj)
+                        
+                return collaborator
+            else:
+                return session.get(Collaborator, collaborator_id)
+    
+    def get_by_ruc_name_code_command(self, content: str, active_only: bool = True, load_relations : bool = False)->List[Collaborator]:
+        with get_session(self.tenant) as session:
+            
+            query = select(Collaborator).where(
+                    or_(
+                        Collaborator.name.ilike(f"%{content}%"),
+                        Collaborator.ruc.ilike(f"%{content}%"),
+                        Collaborator.code.ilike(f"%{content}%")
+                    )
+                )
+            
+            if load_relations:
+                query = select(Collaborator).options(
+                    selectinload(Collaborator.collaborator_type),
+                    joinedload(Collaborator.user),
+                    selectinload(Collaborator.specialties)
+                ).where(
+                    or_(
+                        Collaborator.name.ilike(f"%{content}%"),
+                        Collaborator.ruc.ilike(f"%{content}%"),
+                        Collaborator.code.ilike(f"%{content}%")
+                    )
+                )
+
+            if active_only:
+                query.where(Collaborator.is_active == True)
+                
+            collaborators = session.exec(query).all()
+            
+            return collaborators
+                
+            
+    def get_all_command(self, active_only: bool = True,load_related: bool = False) -> List[Collaborator]:
+        with get_session(self.tenant) as session:
+            
+            
+            if load_related:
+                
+                statement = select(Collaborator).options(
+                    selectinload(Collaborator.specialties)
+                )
+                if active_only:
+                    statement = statement.where(Collaborator.is_active == True)
+                collaborators = session.exec(statement).all()
+                
+                for collaborator in collaborators:
+                    if collaborator.collaborator_type_id:
+                        from models.collaborator.collaborator_type import CollaboratorType
+                        collab_type_obj = session.get(CollaboratorType, collaborator.collaborator_type_id)
+                        object.__setattr__(collaborator,'collaborator_type', collab_type_obj)
+                        
+                    if collaborator.user_id:
+                        from models.user.user import User
+                        user_obj = session.get(User, collaborator.user_id)
+                        object.__setattr__(collaborator,'user',user_obj)
+                return collaborators
+            
+            statement = select(Collaborator)
+            return session.exec(statement).all()
+    
+    def update_command(self, collaborator: Collaborator) -> Collaborator:
+        with get_session(self.tenant) as session:
+            existing_collaborator = session.get(Collaborator, collaborator.collaborator_id)
+            if not existing_collaborator:
+                raise ValueError(f"collaborator with id {collaborator.collaborator_id} does not exist")
+            
+            for key, value in collaborator.dict(exclude_unset=True).items():
+                setattr(existing_collaborator, key, value)
+            
+            bd_collaborator =  session.merge(existing_collaborator)
+            session.commit()
+            session.refresh(bd_collaborator)
+            return bd_collaborator
+        
+    def delete_command(self, collaborator_id: UUID, soft_delete: bool = False)->None:
+        with get_session(self.tenant) as session:
+            existing_bridge = session.get(Collaborator, collaborator_id)
+            if not existing_bridge:
+                raise ValueError(f"Collaborator with id {collaborator_id} does not exist")
+
+            if soft_delete:
+                existing_bridge.is_active = False
+                session.add(existing_bridge)
+            else:
+                session.delete(existing_bridge)
+
+            session.commit()
+    
+    def assign_speciality_command(self, collaborator_id: UUID, speciality_id: UUID) -> Optional[Collaborator]:
+        with get_session(self.tenant) as session:
+            collab_statement = select(Collaborator).options(selectinload(Collaborator.specialties)).where(Collaborator.collaborator_id == collaborator_id)
+            collab = session.exec(collab_statement).first()
+            if not collab:
+                return None
+            
+            speciality = session.get(Speciality, speciality_id)
+            if not speciality:
+                return None
+            
+            if speciality not in collab.specialties:
+                collab.specialties.append(speciality)
+                session.add(collab)
+                session.commit()
+                session.refresh(collab)
+            
+            return collab

repositories/collaborator_repositories/collaborator_type_repository.py

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