healthdatalayer 1.6.6__py3-none-any.whl

healthdatalayer/models/lab/medical_lab.py

@@ -0,0 +1,17 @@
+import uuid
+from typing import Optional,List,TYPE_CHECKING
+from sqlmodel import SQLModel, Field, Relationship
+from .measure_lab import MeasureLab
+if TYPE_CHECKING:
+    from .client_lab import ClientLab
+
+class MedicalLab(SQLModel, table=True):
+    __tablename__ = "medical_lab"
+    
+    medical_lab_id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
+    parameter: str
+    measure_lab_id: Optional[uuid.UUID] = Field(default=None, foreign_key="measure_lab.measure_lab_id")
+    is_active: bool = Field(default=True)
+    
+MedicalLab.measure_lab = Relationship(back_populates="medical_labs")
+MedicalLab.pxs = Relationship(back_populates="medical_labs", link_model="ClientLab")

healthdatalayer/models/medical_visit/medical_diagnosis.py

@@ -0,0 +1,12 @@
+import uuid
+from sqlmodel import SQLModel, Field
+
+class MedicalDiagnosis(SQLModel, table=True):
+    __tablename__ = "medical_diagnosis"
+
+    medical_diagnosis_id:uuid.UUID=Field(default_factory=uuid.uuid4,primary_key=True)
+
+    name:str
+    cie_10_code: str = Field(index=True, max_length=10)
+
+    is_active: bool = Field(default=True)

healthdatalayer/models/medical_visit/medical_diagnosis_visit.py

@@ -0,0 +1,25 @@
+import uuid
+from datetime import datetime
+from typing import Optional, TYPE_CHECKING
+from sqlmodel import SQLModel, Field, Relationship
+from healthdatalayer.models import MedicalDiagnosis
+
+if TYPE_CHECKING:
+    from healthdatalayer.models import MedicalVisit
+
+class MedicalDiagnosisVisit(SQLModel, table=True):
+    __tablename__ = "medical_diagnosis_visit"
+
+    medical_diagnosis_visit_id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
+    diagnosis_date: Optional[datetime] = Field(default=None)
+    comments: str
+    
+    medical_diagnosis_id: Optional[uuid.UUID] = Field(default=None, foreign_key="medical_diagnosis.medical_diagnosis_id")
+    medical_diagnosis: Optional[MedicalDiagnosis] = Relationship()
+    
+    medical_visit_id: Optional[uuid.UUID] = Field(default=None, foreign_key="medical_visit.medical_visit_id")
+    medical_visit: Optional["MedicalVisit"] = Relationship(back_populates="medical_diagnosis_visits")
+    
+    type_diagnosis: str
+
+    is_active: bool = Field(default=True)

healthdatalayer/models/medical_visit/medical_drug.py

@@ -0,0 +1,27 @@
+import uuid
+from datetime import datetime
+from typing import Optional, List, TYPE_CHECKING
+from sqlmodel import SQLModel, Field, Relationship
+
+from healthdatalayer.models.medical_visit.medical_drug_recipe import MedicalDrugRecipe
+
+if TYPE_CHECKING:
+    from healthdatalayer.models.medical_visit.medical_recipe_visit import MedicalRecipeVisit
+
+class MedicalDrug(SQLModel, table=True):
+    __tablename__ = "medical_drug"
+
+    medical_drug_id:uuid.UUID=Field(default_factory=uuid.uuid4,primary_key=True)
+
+    drug_name:str
+    stock:int
+    drug_code:str
+    supply_date: Optional[datetime] = Field(default=None)
+    public_price:float
+
+    is_active: bool = Field(default=True)
+
+    medical_recipe_visits: List["MedicalRecipeVisit"] = Relationship(
+        back_populates="medical_drugs",
+        link_model=MedicalDrugRecipe
+    )

healthdatalayer/models/medical_visit/medical_drug_recipe.py

@@ -0,0 +1,19 @@
+import uuid
+from datetime import datetime
+from typing import Optional
+from sqlmodel import SQLModel, Field
+
+class MedicalDrugRecipe(SQLModel, table=True):
+    __tablename__ = "medical_drug_recipe"
+
+    medical_drug_recipe_id:uuid.UUID=Field(default_factory=uuid.uuid4,primary_key=True)
+
+    medical_drug_id: uuid.UUID = Field(foreign_key="medical_drug.medical_drug_id", primary_key=True)
+    medical_recipe_visit_id: uuid.UUID = Field(foreign_key="medical_recipe_visit.medical_recipe_visit_id", primary_key=True)
+    
+    quantity:int
+    suplied:bool
+    comment:Optional[str] = Field(default=None)
+    suplied_date: Optional[datetime] = Field(default=None)
+
+    is_active: bool = Field(default=True)

healthdatalayer/models/medical_visit/medical_recipe_visit.py

@@ -0,0 +1,28 @@
+import uuid
+from datetime import datetime
+from typing import Optional, List, TYPE_CHECKING
+from sqlmodel import SQLModel, Field, Relationship
+
+
+from healthdatalayer.models import MedicalDrugRecipe
+
+if TYPE_CHECKING:
+    from healthdatalayer.models.medical_visit.medical_drug import MedicalDrug
+    from healthdatalayer.models import MedicalVisit
+
+class MedicalRecipeVisit(SQLModel, table=True):
+    __tablename__ = "medical_recipe_visit"
+    
+    medical_recipe_visit_id: uuid.UUID = Field(default_factory=uuid.uuid4, primary_key=True)
+    completed_supplied: bool
+    completed_supplied_date: Optional[datetime] = Field(default=None)
+    
+    medical_visit_id: Optional[uuid.UUID] = Field(default=None, foreign_key="medical_visit.medical_visit_id")
+    medical_visit: Optional["MedicalVisit"] = Relationship(back_populates="medical_recipe_visits")
+
+    is_active: bool = Field(default=True)
+    
+    medical_drugs: List["MedicalDrug"] = Relationship(
+        back_populates="medical_recipe_visits",
+        link_model=MedicalDrugRecipe
+    )

healthdatalayer/models/medical_visit/medical_visit.py

@@ -0,0 +1,53 @@
+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:
+    from healthdatalayer.models import Px
+    from healthdatalayer.models import MedicalDiagnosisVisit
+    from healthdatalayer.models import MedicalRecipeVisit
+    from healthdatalayer.models import OrganSystemReview
+    from healthdatalayer.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: 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")
+
+    overall_diagnosis:Optional[str]=Field(default=None)
+
+    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)
+    current_illness: 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")

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

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 healthdatalayer.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/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/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 healthdatalayer.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 healthdatalayer.models.user.role_permission import RolePermission
+from healthdatalayer.models.user.permission_user import PermissionUser
+
+if TYPE_CHECKING:
+    from healthdatalayer.models.user.user import User
+    from healthdatalayer.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 healthdatalayer.models.user.role_user import RoleUser
+from healthdatalayer.models.user.role_permission import RolePermission
+
+if TYPE_CHECKING:
+    from healthdatalayer.models.user.user import User
+    from healthdatalayer.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 healthdatalayer.models.user.role_user import RoleUser
+from healthdatalayer.models.user.permission_user import PermissionUser
+
+from healthdatalayer.models.user.role import Role
+from healthdatalayer.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/__init__.py

@@ -0,0 +1,40 @@
+from .client_repositories.address_repository import AddressRepository
+from .client_repositories.client_type_repository import ClientTypeRepository
+from .client_repositories.education_repository import EducationRepository
+from .client_repositories.gender_repository import GenderRepository
+from .client_repositories.marriage_status_repository import MarriageStatusRepository
+from .client_repositories.pet_repository import PetRepository
+from .client_repositories.profession_repository import ProfessionRepository
+from .client_repositories.px_repository import PxRepository
+from .client_repositories.emergency_contact_repository import EmergencyContactRepository
+from .client_repositories.nationality_repository import NationalityRepository
+from .client_repositories.pathological_history_repository import PathologicalHistoryRepository
+
+from .collaborator_repositories.collaborator_repository import CollaboratorRepository
+from .collaborator_repositories.collaborator_type_repository import CollaboratorTypeRepository
+from .collaborator_repositories.speciality_repository import SpecialityRepository
+
+from .infraestructure_repositories.area_repository import AreaRepository
+from .infraestructure_repositories.branch_repository import BranchRepository
+from .infraestructure_repositories.bridge_repository import BridgeAreaFloorBranchRepository
+from .infraestructure_repositories.floor_repository import FloorRepository
+from .infraestructure_repositories.room_repository import RoomRepository
+from .infraestructure_repositories.system_repository import SystemRepository
+
+from .lab_repositories.measure_lab_repository import MeasureLabRepository
+from .lab_repositories.medical_lab_repository import MedicalLabRepository
+
+from .medical_visit_repositories.medical_diagnosis_repository import MedicalDiagnosisRepository
+from .medical_visit_repositories.medical_diagnosis_visit_repository import MedicalDiagnosisVisitRepository
+from .medical_visit_repositories.medical_drug_recipe_repository import MedicalDrugRecipeRepository
+from .medical_visit_repositories.medical_drug_repository import MedicalDrugRepository
+from .medical_visit_repositories.medical_recipe_visit_repository import MedicalRecipeVisitRepository
+from .medical_visit_repositories.medical_visit_repository import MedicalVisitRepository
+from .medical_visit_repositories.organ_system_review_repository import OrganSystemReviewRepository
+from .medical_visit_repositories.physical_exam_repository import PhysicalExamRepository
+from .medical_visit_repositories.visit_triage_repository import VisitTriageRepository
+
+from .user_repositories.permission_repository import PermissionRepository
+from .user_repositories.role_repository import RoleRepository
+from .user_repositories.user_repository import UserRepository
+

healthdatalayer/repositories/client_repositories/address_repository.py

@@ -0,0 +1,94 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+
+from healthdatalayer.models import Address, City, State
+from healthdatalayer.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
+        
+    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/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 healthdatalayer.models import ClientType
+from healthdatalayer.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