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

models/medical_visit/medical_visit.py

@@ -0,0 +1,51 @@
+import uuid
+from datetime import datetime
+from typing import Optional, List, TYPE_CHECKING
+from sqlmodel import SQLModel, Field, Relationship
+
+from models import Collaborator
+
+from models import Speciality
+from models import BridgeAreaFloorBranch 
+if TYPE_CHECKING:
+    from models import Px
+    from models import MedicalDiagnosisVisit
+    from models import MedicalRecipeVisit
+    from models import OrganSystemReview
+    from models import PhysicalExam
+class MedicalVisit(SQLModel, table=True):
+    __tablename__ = "medical_visit"
+
+    medical_visit_id:uuid.UUID=Field(default_factory=uuid.uuid4,primary_key=True)
+    visit_date: Optional[datetime] = Field(default=None)
+
+    collaborator_id:Optional[uuid.UUID]=Field(default=None,foreign_key="collaborator.collaborator_id")
+    collaborator: Optional[Collaborator] = Relationship()
+
+    client_id:Optional[uuid.UUID]=Field(default=None,foreign_key="px.client_id")
+    client: Optional["Px"] = Relationship()
+
+    speciality_id:Optional[uuid.UUID]=Field(default=None,foreign_key="speciality.speciality_id")
+    speciality: Optional[Speciality] = Relationship()
+
+    status_visit:str
+
+    next_followup_visit_id:Optional[uuid.UUID]=Field(default=None,foreign_key="medical_visit.medical_visit_id")
+
+    overall_diagnosis:str
+
+    bridge_area_floor_branch_id:Optional[uuid.UUID]=Field(default=None,foreign_key="bridge_area_floor_branch.bridge_area_floor_branch_id")
+    bridge_area_floor_branch: Optional[BridgeAreaFloorBranch] = Relationship()
+
+    reason_visit:Optional[str]=Field(default=None)
+    rest: Optional[bool] = Field(default=None)
+    rest_hours: Optional[int] = Field(default=None)
+    rest_date_start: Optional[datetime] = Field(default=None)
+    rest_date_end: Optional[datetime] = Field(default=None)
+
+    is_active: bool = Field(default=True)
+    
+    medical_diagnosis_visits: List["MedicalDiagnosisVisit"] = Relationship(back_populates="medical_visit")
+    medical_recipe_visits: List["MedicalRecipeVisit"] = Relationship(back_populates="medical_visit")
+    organ_system_reviews: List["OrganSystemReview"] = Relationship(back_populates="medical_visit")
+    physical_exams: List["PhysicalExam"] = Relationship(back_populates="medical_visit")

models/medical_visit/organ_system_review.py

@@ -0,0 +1,28 @@
+import uuid
+from typing import Optional,TYPE_CHECKING
+from sqlmodel import SQLModel, Field, Relationship
+if TYPE_CHECKING:
+    from models import MedicalVisit
+
+class OrganSystemReview(SQLModel, table=True):
+    __tablename__ = "organ_system_review"
+
+    organ_system_review_id:uuid.UUID=Field(default_factory=uuid.uuid4,primary_key=True)
+
+    medical_visit_id: Optional[uuid.UUID] = Field(default=None, foreign_key="medical_visit.medical_visit_id")
+    medical_visit: Optional["MedicalVisit"] = Relationship(back_populates="organ_system_reviews")
+
+    comment:str
+
+    skin_attachment: Optional[bool] = Field(default=None)
+    sense_organs: Optional[bool] = Field(default=None)
+    breathing: Optional[bool] = Field(default=None)
+    cardiovascular: Optional[bool] = Field(default=None)
+    digestive: Optional[bool] = Field(default=None)
+    genitourinary: Optional[bool] = Field(default=None)
+    skeletal_muscle: Optional[bool] = Field(default=None)
+    endocrine: Optional[bool] = Field(default=None)
+    heme_lifatic: Optional[bool] = Field(default=None)
+    nervous: Optional[bool] = Field(default=None)
+
+    is_active: bool = Field(default=True)

models/medical_visit/physical_exam.py

@@ -0,0 +1,45 @@
+import uuid
+from typing import Optional,TYPE_CHECKING
+from sqlmodel import SQLModel, Field, Relationship
+
+if TYPE_CHECKING:
+    from models import MedicalVisit
+
+class PhysicalExam(SQLModel, table=True):
+    __tablename__ = "physical_exam"
+
+    physical_exam_id:uuid.UUID=Field(default_factory=uuid.uuid4,primary_key=True)
+
+    medical_visit_id: Optional[uuid.UUID] = Field(default=None, foreign_key="medical_visit.medical_visit_id")
+    medical_visit: Optional["MedicalVisit"] = Relationship(back_populates="physical_exams")
+
+    comments: Optional[str] = Field(default=None)
+    
+    r1: Optional[bool] = Field(default=None)
+    r2: Optional[bool] = Field(default=None)
+    r3: Optional[bool] = Field(default=None)
+    r4: Optional[bool] = Field(default=None)
+    r5: Optional[bool] = Field(default=None)
+    r6: Optional[bool] = Field(default=None)
+    r7: Optional[bool] = Field(default=None)
+    r8: Optional[bool] = Field(default=None)
+    r9: Optional[bool] = Field(default=None)
+    r10: Optional[bool] = Field(default=None)
+    r11: Optional[bool] = Field(default=None)
+    r12: Optional[bool] = Field(default=None)
+    r13: Optional[bool] = Field(default=None)
+    r14: Optional[bool] = Field(default=None)
+    r15: Optional[bool] = Field(default=None)
+
+    s1: Optional[bool] = Field(default=None)
+    s2: Optional[bool] = Field(default=None)
+    s3: Optional[bool] = Field(default=None)
+    s4: Optional[bool] = Field(default=None)
+    s5: Optional[bool] = Field(default=None)
+    s6: Optional[bool] = Field(default=None)
+    s7: Optional[bool] = Field(default=None)
+    s8: Optional[bool] = Field(default=None)
+    s9: Optional[bool] = Field(default=None)
+    s10: Optional[bool] = Field(default=None)
+
+    is_active: bool = Field(default=True)

models/medical_visit/visit_triage.py

@@ -0,0 +1,28 @@
+import uuid
+from typing import Optional,TYPE_CHECKING
+from sqlmodel import SQLModel, Field, Relationship
+from decimal import Decimal
+
+if TYPE_CHECKING:
+    from models.medical_visit.medical_visit import MedicalVisit
+
+class VisitTriage(SQLModel, table=True):
+    __tablename__ = "visit_triage"
+
+    visit_triage_id:uuid.UUID=Field(default_factory=uuid.uuid4,primary_key=True)
+    
+    weight:Optional[Decimal]=Field(default=None)
+    height:Optional[Decimal]=Field(default=None)
+    heart_rate:Optional[int]=Field(default=None)
+    blood_pressure:Optional[str]=Field(default=None)
+    temperature:Optional[Decimal]=Field(default=None)
+
+    imc:Optional[Decimal]=Field(default=None)
+    abdominal_perimeter:Optional[Decimal]=Field(default=None)
+    capillary_hemoglobin:Optional[Decimal]=Field(default=None)
+    pulse_oximetry:Optional[Decimal]=Field(default=None)
+    
+    medical_visit_id:Optional[uuid.UUID]=Field(default=None,foreign_key="medical_visit.medical_visit_id")
+    medical_visit: Optional["MedicalVisit"] = Relationship()
+
+    is_active: bool = Field(default=True)

models/user/permission.py

@@ -0,0 +1,27 @@
+import uuid
+from sqlmodel import SQLModel, Field, Relationship
+from typing import List, TYPE_CHECKING
+
+from models.user.role_permission import RolePermission
+from models.user.permission_user import PermissionUser
+
+if TYPE_CHECKING:
+    from models.user.user import User
+    from models.user.role import Role
+
+class Permission(SQLModel, table=True):
+    __tablename__ = "permission"
+
+    permission_id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
+    name: str
+    is_active: bool
+
+    roles: List["Role"] = Relationship(
+        back_populates="permissions",
+        link_model=RolePermission
+    )
+
+    users: List["User"] = Relationship(
+        back_populates="permissions",
+        link_model=PermissionUser
+    )

models/user/permission_user.py

@@ -0,0 +1,8 @@
+import uuid
+from sqlmodel import SQLModel,Field
+
+class PermissionUser(SQLModel,table=True):
+    __tablename__ = "permission_user"
+    
+    permission_id: uuid.UUID = Field(foreign_key="permission.permission_id", primary_key=True)
+    user_id: uuid.UUID = Field(foreign_key="user.user_id", primary_key=True)

models/user/role.py

@@ -0,0 +1,27 @@
+import uuid
+from sqlmodel import SQLModel, Field, Relationship
+from typing import List, TYPE_CHECKING
+
+from models.user.role_user import RoleUser
+from models.user.role_permission import RolePermission
+
+if TYPE_CHECKING:
+    from models.user.user import User
+    from models.user.permission import Permission
+
+class Role(SQLModel, table=True):
+    __tablename__ = "role"
+
+    role_id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
+    name: str
+    is_active: bool
+
+    users: List["User"] = Relationship(
+        back_populates="roles",
+        link_model=RoleUser
+    )
+
+    permissions: List["Permission"] = Relationship(
+        back_populates="roles",
+        link_model=RolePermission
+    )

models/user/role_permission.py

@@ -0,0 +1,8 @@
+import uuid
+from sqlmodel import SQLModel,Field
+
+class RolePermission(SQLModel,table=True):
+    __tablename__ = "role_permission"
+    
+    role_id: uuid.UUID = Field(foreign_key="role.role_id", primary_key=True)
+    permission_id: uuid.UUID = Field(foreign_key="permission.permission_id", primary_key=True)

models/user/role_user.py

@@ -0,0 +1,8 @@
+import uuid
+from sqlmodel import SQLModel,Field
+
+class RoleUser(SQLModel,table=True):
+    __tablename__ = "role_user"
+    
+    role_id: uuid.UUID = Field(foreign_key="role.role_id", primary_key=True)
+    user_id: uuid.UUID = Field(foreign_key="user.user_id", primary_key=True)

models/user/user.py

@@ -0,0 +1,30 @@
+import uuid
+from sqlmodel import SQLModel,Field, Relationship
+from datetime import datetime
+from typing import Optional, List, TYPE_CHECKING
+
+from models.user.role_user import RoleUser
+from models.user.permission_user import PermissionUser
+
+from models.user.role import Role
+from models.user.permission import Permission
+    
+class User(SQLModel,table=True):
+    __tablename__ = "user"
+
+    user_id:uuid.UUID=Field(default_factory=uuid.uuid4,primary_key=True)
+    username: str = Field(index=True, nullable=False, unique=True)
+    password: str = Field(nullable=False)
+    last_access: Optional[datetime] = Field(default=None)
+    email: Optional[str] = None
+    is_active: bool 
+
+    roles: List["Role"] = Relationship(
+        back_populates="users",
+        link_model=RoleUser
+    )
+
+    permissions: List["Permission"] = Relationship(
+        back_populates="users",
+        link_model=PermissionUser
+    )

repositories/client_repositories/address_repository.py

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

repositories/client_repositories/client_type_repository.py

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

repositories/client_repositories/education_repository.py

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

repositories/client_repositories/gender_repository.py

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

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 models import MarriageStatus
+from 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