healthdatalayer 1.6.6__py3-none-any.whl

healthdatalayer/repositories/client_repositories/px_repository.py

@@ -0,0 +1,239 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+
+from healthdatalayer.models import Px
+from healthdatalayer.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 healthdatalayer.models.client.gender import Gender
+                    gender_obj = session.get(Gender, px.gender_id)
+                    object.__setattr__(px, 'gender', gender_obj)
+                
+                if px.address_id:
+                    from healthdatalayer.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 healthdatalayer.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 healthdatalayer.models.client.profession import Profession
+                    profession_obj = session.get(Profession, px.profession_id)
+                    object.__setattr__(px, 'profession', profession_obj)
+                
+                if px.education_id:
+                    from healthdatalayer.models.client.education import Education
+                    education_obj = session.get(Education, px.education_id)
+                    object.__setattr__(px, 'education', education_obj)
+                
+                if px.user_id:
+                    from healthdatalayer.models.user.user import User
+                    user_obj = session.get(User, px.user_id)
+                    object.__setattr__(px, 'user', user_obj)
+                    
+                if px.nationality_id:
+                    from healthdatalayer.models.client.nationality import Nationality
+                    user_obj = session.get(Nationality, px.nationality_id)
+                    object.__setattr__(px, 'nationality', user_obj)
+                    
+                from healthdatalayer.models.client.pathological_history import PathologicalHistory
+                statement = select(PathologicalHistory).where(PathologicalHistory.client_id == px_id)
+                pathological_his = session.exec(statement).all()
+                if pathological_his:
+                    object.__setattr__(px, 'pathological_histories',pathological_his)
+            
+            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 healthdatalayer.models.client.gender import Gender
+                    gender_obj = session.get(Gender, px.gender_id)
+                    object.__setattr__(px, 'gender', gender_obj)
+                
+                if px.address_id:
+                    from healthdatalayer.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 healthdatalayer.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 healthdatalayer.models.client.profession import Profession
+                    profession_obj = session.get(Profession, px.profession_id)
+                    object.__setattr__(px, 'profession', profession_obj)
+                
+                if px.education_id:
+                    from healthdatalayer.models.client.education import Education
+                    education_obj = session.get(Education, px.education_id)
+                    object.__setattr__(px, 'education', education_obj)
+                
+                if px.user_id:
+                    from healthdatalayer.models.user.user import User
+                    user_obj = session.get(User, px.user_id)
+                    object.__setattr__(px, 'user', user_obj)
+                    
+                if px.nationality_id:
+                    from healthdatalayer.models.client.nationality import Nationality
+                    user_obj = session.get(Nationality, px.nationality_id)
+                    object.__setattr__(px, 'nationality', 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}%")) |
+                (Px.identification.ilike(f"%{name}%"))
+            )
+            
+            results = session.exec(statement).all()
+            
+            if load_relations:
+                for px in results:
+                    if px.gender_id:
+                        from healthdatalayer.models.client.gender import Gender
+                        gender_obj = session.get(Gender, px.gender_id)
+                        object.__setattr__(px, 'gender', gender_obj)
+                    
+                    if px.address_id:
+                        from healthdatalayer.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 healthdatalayer.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 healthdatalayer.models.client.profession import Profession
+                        profession_obj = session.get(Profession, px.profession_id)
+                        object.__setattr__(px, 'profession', profession_obj)
+                    
+                    if px.education_id:
+                        from healthdatalayer.models.client.education import Education
+                        education_obj = session.get(Education, px.education_id)
+                        object.__setattr__(px, 'education', education_obj)
+                    
+                    if px.user_id:
+                        from healthdatalayer.models.user.user import User
+                        user_obj = session.get(User, px.user_id)
+                        object.__setattr__(px, 'user', user_obj)
+                    if px.nationality_id:
+                        from healthdatalayer.models.client.nationality import Nationality
+                        user_obj = session.get(Nationality, px.nationality_id)
+                        object.__setattr__(px, 'nationality', 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 healthdatalayer.models.client.gender import Gender
+                        gender_obj = session.get(Gender, px.gender_id)
+                        object.__setattr__(px, 'gender', gender_obj)
+                    
+                    if px.address_id:
+                        from healthdatalayer.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 healthdatalayer.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 healthdatalayer.models.client.profession import Profession
+                        profession_obj = session.get(Profession, px.profession_id)
+                        object.__setattr__(px, 'profession', profession_obj)
+                    
+                    if px.education_id:
+                        from healthdatalayer.models.client.education import Education
+                        education_obj = session.get(Education, px.education_id)
+                        object.__setattr__(px, 'education', education_obj)
+                    
+                    if px.user_id:
+                        from healthdatalayer.models.user.user import User
+                        user_obj = session.get(User, px.user_id)
+                        object.__setattr__(px, 'user', user_obj)
+                        
+                    if px.nationality_id:
+                        from healthdatalayer.models.client.nationality import Nationality
+                        user_obj = session.get(Nationality, px.nationality_id)
+                        object.__setattr__(px, 'nationality', 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())

healthdatalayer/repositories/collaborator_repositories/collaborator_repository.py

@@ -0,0 +1,197 @@
+from datetime import date
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select, or_, join, text
+from sqlalchemy.orm import selectinload,joinedload
+from healthdatalayer.models import Collaborator
+from healthdatalayer.models import Speciality, CollaboratorSpeciality
+from healthdatalayer.dtos import ScheduleCollaboratorDTO
+from healthdatalayer.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.collaborator_type),
+                    joinedload(Collaborator.user),
+                    selectinload(Collaborator.specialties) 
+                )
+                collaborator = session.exec(statement).first()
+                        
+                return collaborator
+            else:
+                return session.get(Collaborator, collaborator_id)
+            
+    def get_by_speciality_id_command(self, speciality_id: UUID, load_relations: bool = False) -> List[Collaborator]:
+        with get_session(self.tenant) as session:
+            statement = (
+                select(Collaborator)
+                .join(CollaboratorSpeciality)
+                .where(CollaboratorSpeciality.speciality_id == speciality_id, Collaborator.is_active == True)
+            )
+            
+            if load_relations:
+                statement = statement.options(
+                    selectinload(Collaborator.collaborator_type),
+                    joinedload(Collaborator.user),
+                    selectinload(Collaborator.specialties)    
+                )
+                
+            collaborators = session.exec(statement).all()
+                        
+            return collaborators
+    
+    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:
+            
+            statement = select(Collaborator)
+            
+            if load_related:
+                
+                statement = statement.options(
+                    selectinload(Collaborator.collaborator_type),
+                    joinedload(Collaborator.user),
+                    selectinload(Collaborator.specialties) 
+                )         
+            
+            if active_only:
+                statement = statement.where(Collaborator.is_active == True)
+                
+            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
+    
+    def get_availability_schedules_command(self, visit_date: date, collaborator_id: str) -> ScheduleCollaboratorDTO:
+    
+        with get_session(self.tenant) as session:
+            
+            query = text("""
+                WITH horarios_generados AS (
+                    SELECT horario::TIME as hora
+                    FROM generate_series(
+                        CAST(:fecha AS DATE)+ TIME '08:00:00',
+                        CAST(:fecha AS DATE) + TIME '17:00:00',
+                        INTERVAL '30 minutes'
+                    ) AS horario
+                ),
+                horarios_ocupados AS (
+                    SELECT t.visit_date::TIME as hora
+                    FROM medical_visit t
+                    WHERE t.visit_date::DATE = :fecha
+                    AND t.collaborator_id = :colab_id
+                    AND t.status_visit in ('AGENDADO','REAGENDADO')
+                )
+                SELECT 
+                    hg.hora,
+                    CASE WHEN ho.hora IS NOT NULL THEN true ELSE false END as ocupado
+                FROM horarios_generados hg
+                LEFT JOIN horarios_ocupados ho ON hg.hora = ho.hora
+                ORDER BY hg.hora
+            """)
+            
+            result = session.exec(query, params={"fecha": visit_date, "colab_id": collaborator_id})
+            
+            availables = []
+            busy = []
+            
+            for row in result.fetchall():
+                hour, is_busy = row[0], row[1]
+                if is_busy:
+                    busy.append(hour)
+                else:
+                    availables.append(hour)
+            
+            return ScheduleCollaboratorDTO(
+                available_schedules=availables,
+                busy_schedules=busy
+            )

healthdatalayer/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 healthdatalayer.models import CollaboratorType
+from healthdatalayer.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

healthdatalayer/repositories/collaborator_repositories/speciality_repository.py

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

healthdatalayer/repositories/infraestructure_repositories/area_repository.py

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