healthdatalayer 1.4.3__tar.gz → 1.4.5__tar.gz

{healthdatalayer-1.4.3 → healthdatalayer-1.4.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: healthdatalayer
-Version: 1.4.3
+Version: 1.4.5
 Summary: Health Datalayer to access data from different sources
 Author: Jesus Martinez
 Author-email: jesusmartinez@noosds.com

{healthdatalayer-1.4.3 → healthdatalayer-1.4.5}/healthdatalayer/models/__init__.py

@@ -24,6 +24,8 @@ from .client.pathological_history import PathologicalHistory
 from .client.pet import Pet
 from .client.profession import Profession
 from .client.px import Px
+from .client.state import State
+from .client.city import City
 
 from .collaborator.collaborator_speciality import CollaboratorSpeciality
 from .collaborator.collaborator import Collaborator

healthdatalayer-1.4.5/healthdatalayer/models/client/city.py

@@ -0,0 +1,11 @@
+import uuid
+from sqlmodel import SQLModel,Field
+from typing import Optional
+
+class City(SQLModel,table=True):
+    __tablename__ = "city"
+    
+    city_id:uuid.UUID=Field(default_factory=uuid.uuid4,primary_key=True)
+    name:str
+    state_id: Optional[uuid.UUID] = Field(default=None, foreign_key="state.state_id")
+    is_active: bool = Field(default=True)

{healthdatalayer-1.4.3 → healthdatalayer-1.4.5}/healthdatalayer/models/client/px.py

@@ -20,9 +20,11 @@ class Px(Client, table=True):
     profession_id: Optional[uuid.UUID] = Field(default=None, foreign_key="profession.profession_id")
     education_id: Optional[uuid.UUID] = Field(default=None, foreign_key="education.education_id")
     user_id: Optional[uuid.UUID] = Field(default=None, foreign_key="user.user_id")
+    nationality_id: Optional[uuid.UUID] = Field(default=None, foreign_key="nationality.nationality_id")
 
 Px.marriage_status = Relationship()
 Px.profession = Relationship()
 Px.education = Relationship()
 Px.user = Relationship()
+Px.nationality = Relationship()
 Px.medical_labs = Relationship(back_populates="pxs", link_model="ClientLab")

healthdatalayer-1.4.5/healthdatalayer/models/client/state.py

@@ -0,0 +1,9 @@
+import uuid
+from sqlmodel import SQLModel,Field
+
+class State(SQLModel,table=True):
+    __tablename__ = "state"
+    
+    state_id:uuid.UUID=Field(default_factory=uuid.uuid4,primary_key=True)
+    name:str
+    is_active: bool = Field(default=True)

{healthdatalayer-1.4.3 → healthdatalayer-1.4.5}/healthdatalayer/models/medical_visit/medical_visit.py

@@ -2,9 +2,10 @@ import uuid
 from datetime import datetime
 from typing import Optional, List, TYPE_CHECKING
 from sqlmodel import SQLModel, Field, Relationship
+from sqlalchemy import Column, Enum as SqlEnum
 
 from healthdatalayer.models import Collaborator
-
+from healthdatalayer.models.medical_visit.status_visit_enum import StatusVisitEnum
 from healthdatalayer.models import Speciality
 from healthdatalayer.models import BridgeAreaFloorBranch 
 if TYPE_CHECKING:
@@ -28,7 +29,7 @@ class MedicalVisit(SQLModel, table=True):
     speciality_id:Optional[uuid.UUID]=Field(default=None,foreign_key="speciality.speciality_id")
     speciality: Optional[Speciality] = Relationship()
 
-    status_visit:str
+    status_visit: StatusVisitEnum = Field(sa_column=Column(SqlEnum(StatusVisitEnum, native_enum=False), nullable=False))
 
     next_followup_visit_id:Optional[uuid.UUID]=Field(default=None,foreign_key="medical_visit.medical_visit_id")
 

healthdatalayer-1.4.5/healthdatalayer/models/medical_visit/status_visit_enum.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class StatusVisitEnum(str, Enum):
+    AGENDADO = "AGENDADO"
+    REAGENDADO = "REAGENDADO"
+    CANCELADO = "CANCELADO"
+    ATENDIDO = "ATENDIDO"
+    NO_ATENDIDO = "NO_ATENDIDO"

{healthdatalayer-1.4.3 → healthdatalayer-1.4.5}/healthdatalayer/repositories/client_repositories/address_repository.py

@@ -2,7 +2,7 @@ from typing import Optional, List
 from uuid import UUID
 from sqlmodel import select
 
-from healthdatalayer.models import Address
+from healthdatalayer.models import Address, City, State
 from healthdatalayer.config.db import engines, get_session
 
 class AddressRepository:
@@ -61,4 +61,34 @@ class AddressRepository:
                 session.delete(db_address)
             
             session.commit()
-            return True
+            return True
+        
+    def list_all_state_command(self, active_only: bool = True) -> List[Address]:
+        with get_session(self.tenant) as session:
+            statement = select(State)
+            
+            if active_only:
+                statement = statement.where(State.is_active == True)
+            
+            results = session.exec(statement)
+            return results.all()
+    
+    def list_all_city_command(self, active_only: bool = True) -> List[Address]:
+        with get_session(self.tenant) as session:
+            statement = select(City)
+            
+            if active_only:
+                statement = statement.where(City.is_active == True)
+            
+            results = session.exec(statement)
+            return results.all()
+    
+    def list_city_by_state_id_command(self,state_id: UUID, active_only: bool = True) -> List[Address]:
+        with get_session(self.tenant) as session:
+            statement = select(City).where(City.state_id == state_id)
+            
+            if active_only:
+                statement = statement.where(State.is_active == True)
+            
+            results = session.exec(statement)
+            return results.all()

healthdatalayer-1.4.5/healthdatalayer/repositories/medical_visit_repositories/medical_visit_repository.py

@@ -0,0 +1,234 @@
+from typing import Optional, List
+from datetime import datetime
+from uuid import UUID
+from sqlmodel import select
+from sqlalchemy.orm import selectinload,joinedload
+from healthdatalayer.models import MedicalVisit
+from healthdatalayer.config.db import engines, get_session
+
+class MedicalVisitRepository:
+    def __init__(self, tenant: str):
+        self.tenant = tenant
+        if tenant not in engines:
+            raise ValueError(f"Tenant {tenant} is not configured")
+    
+    def create_command(self, medical_visit: MedicalVisit) -> MedicalVisit:
+        with get_session(self.tenant) as session:
+            session.add(medical_visit)
+            session.commit()
+            session.refresh(medical_visit)
+            return medical_visit
+    
+    def get_by_id_command(self, medical_visit_id: UUID, load_relations: bool = False) -> Optional[MedicalVisit]:
+        with get_session(self.tenant) as session:
+            
+            if load_relations:
+                statement = select(MedicalVisit).where(MedicalVisit.medical_visit_id == medical_visit_id).options(
+                    joinedload(MedicalVisit.client),
+                    joinedload(MedicalVisit.collaborator),
+                    joinedload(MedicalVisit.speciality),
+                    selectinload(MedicalVisit.medical_diagnosis_visits),
+                    selectinload(MedicalVisit.medical_recipe_visits),
+                    selectinload(MedicalVisit.organ_system_reviews),
+                    selectinload(MedicalVisit.physical_exams)
+                )
+                medical_visit = session.exec(statement).first()
+               
+                return medical_visit
+            else:
+                return session.get(MedicalVisit, medical_visit_id)
+    
+    def list_all_command(self, active_only: bool = True, load_relations: bool = False)->List[MedicalVisit]:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalVisit)
+            
+            if load_relations:
+                
+                statement = select(MedicalVisit).options(
+                    joinedload(MedicalVisit.client),
+                    joinedload(MedicalVisit.collaborator),
+                    joinedload(MedicalVisit.speciality),
+                    selectinload(MedicalVisit.medical_diagnosis_visits),
+                    selectinload(MedicalVisit.medical_recipe_visits),
+                    selectinload(MedicalVisit.organ_system_reviews),
+                    selectinload(MedicalVisit.physical_exams)
+                )
+                if active_only:
+                    statement = statement.where(MedicalVisit.is_active == True)
+                medical_visits = session.exec(statement).all()
+              
+                return medical_visits
+            
+            statement = select(MedicalVisit)
+            return session.exec(statement).all()
+    
+    def get_by_client_id_command(self, client_id: UUID, active_only: bool = True, load_relations: bool = False) -> List[MedicalVisit]:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalVisit).where(MedicalVisit.client_id == client_id)
+            if active_only:
+                statement = statement.where(MedicalVisit.is_active == True)
+            if load_relations:
+                statement = statement.options(
+                    joinedload(MedicalVisit.client),
+                    joinedload(MedicalVisit.collaborator),
+                    joinedload(MedicalVisit.speciality),
+                    selectinload(MedicalVisit.medical_diagnosis_visits),
+                    selectinload(MedicalVisit.medical_recipe_visits),
+                    selectinload(MedicalVisit.organ_system_reviews),
+                    selectinload(MedicalVisit.physical_exams)
+                )
+            
+            medical_visits = session.exec(statement).all()
+            return medical_visits
+        
+    def get_by_collaborator_id_command(self, collaborator_id: UUID, active_only: bool = True, load_relations: bool = False) -> List[MedicalVisit]:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalVisit).where(MedicalVisit.collaborator_id == collaborator_id)
+            
+            if active_only:
+                statement = statement.where(MedicalVisit.is_active == True)
+            if load_relations:
+                statement = statement.options(
+                    joinedload(MedicalVisit.client),
+                    joinedload(MedicalVisit.collaborator),
+                    joinedload(MedicalVisit.speciality),
+                    selectinload(MedicalVisit.medical_diagnosis_visits),
+                    selectinload(MedicalVisit.medical_recipe_visits),
+                    selectinload(MedicalVisit.organ_system_reviews),
+                    selectinload(MedicalVisit.physical_exams)
+                )
+            
+            medical_visits = session.exec(statement).all()
+            return medical_visits
+        
+    def get_by_next_followup_id_command(self, next_followup_id: UUID, active_only: bool = True, load_relations: bool = False) -> List[MedicalVisit]:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalVisit).where(MedicalVisit.next_followup_visit_id == next_followup_id)
+            
+            if active_only:
+                statement = statement.where(MedicalVisit.is_active == True)
+            if load_relations:
+                statement = statement.options(
+                    joinedload(MedicalVisit.client),
+                    joinedload(MedicalVisit.collaborator),
+                    joinedload(MedicalVisit.speciality),
+                    selectinload(MedicalVisit.medical_diagnosis_visits),
+                    selectinload(MedicalVisit.medical_recipe_visits),
+                    selectinload(MedicalVisit.organ_system_reviews),
+                    selectinload(MedicalVisit.physical_exams)
+                )
+            
+            medical_visits = session.exec(statement).all()
+            return medical_visits
+        
+    def get_by_collaboratorid_and_daterange_command(self, collaborator_id: UUID, start_date: datetime, end_date: datetime, active_only: bool = True, load_relations: bool = False) -> List[MedicalVisit]:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalVisit).where(
+                    MedicalVisit.collaborator_id == collaborator_id,
+                    MedicalVisit.visit_date >= start_date
+                )
+            
+            if end_date is not None:
+                statement = statement.where(MedicalVisit.visit_date <= end_date)
+            if active_only:
+                statement = statement.where(MedicalVisit.is_active == True)
+            if load_relations:
+                statement = statement.options(
+                    joinedload(MedicalVisit.client),
+                    joinedload(MedicalVisit.collaborator),
+                    joinedload(MedicalVisit.speciality),
+                    selectinload(MedicalVisit.medical_diagnosis_visits),
+                    selectinload(MedicalVisit.medical_recipe_visits),
+                    selectinload(MedicalVisit.organ_system_reviews),
+                    selectinload(MedicalVisit.physical_exams)
+                )
+            
+            medical_visits = session.exec(statement).all()
+            return medical_visits
+        
+    def get_by_collaboratorid_and_targetdate_command(self, collaborator_id: UUID, target_date: datetime, active_only: bool = True, load_relations: bool = False) -> List[MedicalVisit]:
+        with get_session(self.tenant) as session:
+
+            start_of_day = datetime.combine(target_date.date(), datetime.min.time())
+            end_of_day = datetime.combine(target_date.date(), datetime.max.time())
+
+            statement = select(MedicalVisit).where(
+                    MedicalVisit.collaborator_id == collaborator_id,
+                    MedicalVisit.visit_date >= start_of_day,
+                    MedicalVisit.visit_date <= end_of_day
+                )
+
+            if active_only:
+                statement = statement.where(MedicalVisit.is_active == True)
+            if load_relations:
+                statement = statement.options(
+                    joinedload(MedicalVisit.client),
+                    joinedload(MedicalVisit.collaborator),
+                    joinedload(MedicalVisit.speciality),
+                    selectinload(MedicalVisit.medical_diagnosis_visits),
+                    selectinload(MedicalVisit.medical_recipe_visits),
+                    selectinload(MedicalVisit.organ_system_reviews),
+                    selectinload(MedicalVisit.physical_exams)
+                )
+            
+            medical_visits = session.exec(statement).all()
+            return medical_visits
+    
+    def get_by_collaboratorid_and_specificdatetime_command(self, collaborator_id: UUID, specific_datetime: datetime, active_only: bool = True, load_relations: bool = False) -> Optional[MedicalVisit]:
+        with get_session(self.tenant) as session:
+
+            statement = select(MedicalVisit).where(
+                    MedicalVisit.collaborator_id == collaborator_id,
+                    MedicalVisit.visit_date == specific_datetime
+                )
+
+            if active_only:
+                statement = statement.where(MedicalVisit.is_active == True)
+            if load_relations:
+                statement = statement.options(
+                    joinedload(MedicalVisit.client),
+                    joinedload(MedicalVisit.collaborator),
+                    joinedload(MedicalVisit.speciality),
+                    selectinload(MedicalVisit.medical_diagnosis_visits),
+                    selectinload(MedicalVisit.medical_recipe_visits),
+                    selectinload(MedicalVisit.organ_system_reviews),
+                    selectinload(MedicalVisit.physical_exams)
+                )
+            
+            medical_visit = session.exec(statement).first()
+            return medical_visit
+    
+    def update_command(self, medical_visit: MedicalVisit) -> MedicalVisit:
+        with get_session(self.tenant) as session:
+            existing_medical_visit = session.get(MedicalVisit, medical_visit.medical_visit_id)
+            if not existing_medical_visit:
+                raise ValueError(f"medical_visit with id {medical_visit.medical_visit_id} does not exist")
+            
+            for key, value in medical_visit.dict(exclude_unset=True).items():
+                setattr(existing_medical_visit, key, value)
+            
+            bd_medical_visit =  session.merge(existing_medical_visit)
+            session.commit()
+            session.refresh(bd_medical_visit)
+            return bd_medical_visit
+        
+    def delete_command(self, medical_visit_id: UUID, soft_delete: bool = False)->None:
+        with get_session(self.tenant) as session:
+            existing_bridge = session.get(MedicalVisit, medical_visit_id)
+            if not existing_bridge:
+                raise ValueError(f"MedicalVisit with id {medical_visit_id} does not exist")
+
+            if soft_delete:
+                existing_bridge.is_active = False
+                session.add(existing_bridge)
+            else:
+                session.delete(existing_bridge)
+
+            session.commit()
+    
+    def exists_by_collaboratoid_and_targetdate_command(self, collaborator_id: UUID, target_date: datetime) -> bool:
+        with get_session(self.tenant) as session:
+            statement = select(MedicalVisit).where(MedicalVisit.collaborator_id == collaborator_id, MedicalVisit.visit_date == target_date)
+            result = session.exec(statement).first()
+            return result is not None
+    

{healthdatalayer-1.4.3 → healthdatalayer-1.4.5}/healthdatalayer.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: healthdatalayer
-Version: 1.4.3
+Version: 1.4.5
 Summary: Health Datalayer to access data from different sources
 Author: Jesus Martinez
 Author-email: jesusmartinez@noosds.com

{healthdatalayer-1.4.3 → healthdatalayer-1.4.5}/healthdatalayer.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ healthdatalayer/models/bridge_area_floor_branch/room.py
 healthdatalayer/models/bridge_area_floor_branch/system.py
 healthdatalayer/models/client/__init__.py
 healthdatalayer/models/client/address.py
+healthdatalayer/models/client/city.py
 healthdatalayer/models/client/client.py
 healthdatalayer/models/client/client_type.py
 healthdatalayer/models/client/education.py
@@ -31,6 +32,7 @@ healthdatalayer/models/client/pathological_history.py
 healthdatalayer/models/client/pet.py
 healthdatalayer/models/client/profession.py
 healthdatalayer/models/client/px.py
+healthdatalayer/models/client/state.py
 healthdatalayer/models/collaborator/__init__.py
 healthdatalayer/models/collaborator/collaborator.py
 healthdatalayer/models/collaborator/collaborator_speciality.py
@@ -49,6 +51,7 @@ healthdatalayer/models/medical_visit/medical_recipe_visit.py
 healthdatalayer/models/medical_visit/medical_visit.py
 healthdatalayer/models/medical_visit/organ_system_review.py
 healthdatalayer/models/medical_visit/physical_exam.py
+healthdatalayer/models/medical_visit/status_visit_enum.py
 healthdatalayer/models/medical_visit/visit_triage.py
 healthdatalayer/models/user/__init__.py
 healthdatalayer/models/user/permission.py

{healthdatalayer-1.4.3 → healthdatalayer-1.4.5}/setup.py

@@ -5,7 +5,7 @@ with open('requirements.txt') as f:
 
 setup(
     name="healthdatalayer",
-    version="1.4.3",
+    version="1.4.5",
     include_package_data=True,
     python_requires='>=3.10',
     packages=find_packages(),

healthdatalayer-1.4.3/healthdatalayer/repositories/medical_visit_repositories/medical_visit_repository.py

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