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

healthdatalayer/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)

healthdatalayer/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)

healthdatalayer/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
+    )

healthdatalayer/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)

healthdatalayer/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
+    )

healthdatalayer/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)

healthdatalayer/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)

healthdatalayer/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
+    )

healthdatalayer/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

healthdatalayer/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

healthdatalayer/repositories/client_repositories/education_repository.py

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

healthdatalayer/repositories/client_repositories/gender_repository.py

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

healthdatalayer/repositories/client_repositories/marriage_status_repository.py

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

healthdatalayer/repositories/client_repositories/pet_repository.py

@@ -0,0 +1,126 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+from sqlalchemy.orm import selectinload
+
+from 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())