healthdatalayer 1.6.6__py3-none-any.whl

healthdatalayer/repositories/medical_visit_repositories/organ_system_review_repository.py

@@ -0,0 +1,89 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select, or_
+from sqlalchemy.orm import selectinload,joinedload
+from healthdatalayer.models import OrganSystemReview
+from healthdatalayer.models import MedicalVisit
+from healthdatalayer.config.db import engines, get_session
+
+class OrganSystemReviewRepository:
+    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, organ_system_review: OrganSystemReview) -> OrganSystemReview:
+        with get_session(self.tenant) as session:
+            session.add(organ_system_review)
+            session.commit()
+            session.refresh(organ_system_review)
+            return organ_system_review
+    
+    def get_by_id_command(self, organ_system_review_id: UUID, load_relations: bool = False) -> Optional[OrganSystemReview]:
+        with get_session(self.tenant) as session:
+            
+            if load_relations:
+                statement = select(OrganSystemReview).where(OrganSystemReview.organ_system_review_id == organ_system_review_id).options(
+                    joinedload(OrganSystemReview.medical_visit)
+                )
+                organ_system_review = session.exec(statement).first()
+               
+                return organ_system_review
+            else:
+                return session.get(OrganSystemReview, organ_system_review_id)
+    
+    def get_by_medical_visit_id_command(self, medical_visit_id: UUID, load_relations: bool = False) ->Optional[OrganSystemReview]:
+        with get_session(self.tenant) as session:
+            
+            statement = select(OrganSystemReview).where(OrganSystemReview.medical_visit_id == medical_visit_id)
+            if load_relations:
+                statement = statement.options(
+                    joinedload(OrganSystemReview.medical_visit)
+                )
+            organ_system_review = session.exec(statement).first()
+            
+            return organ_system_review 
+    
+    def get_all_command(self, active_only: bool = True,load_related: bool = False) -> List[OrganSystemReview]:
+        with get_session(self.tenant) as session:
+            
+            statement = select(OrganSystemReview)
+            
+            if load_related:
+                statement = select(OrganSystemReview).options(
+                    selectinload(OrganSystemReview.medical_visit)
+                )
+            
+            if active_only:
+                statement = statement.where(OrganSystemReview.is_active == True)
+                organ_system_review = session.exec(statement).all()
+                
+            return organ_system_review
+        
+    def update_command(self, organ_system_review: OrganSystemReview) -> OrganSystemReview:
+        with get_session(self.tenant) as session:
+            existing_organ_system_review = session.get(OrganSystemReview, organ_system_review.organ_system_review_id)
+            if not existing_organ_system_review:
+                raise ValueError(f"triage with id {organ_system_review.organ_system_review_id} does not exist")
+            
+            for key, value in organ_system_review.dict(exclude_unset=True).items():
+                setattr(existing_organ_system_review, key, value)
+            
+            bd_organ_system_review =  session.merge(existing_organ_system_review)
+            session.commit()
+            session.refresh(bd_organ_system_review)
+            return bd_organ_system_review
+        
+    def delete_command(self, organ_system_review_id: UUID, soft_delete: bool = False)->None:
+        with get_session(self.tenant) as session:
+            existing_organ_system_review = session.get(OrganSystemReview, organ_system_review_id)
+            if not existing_organ_system_review:
+                raise ValueError(f"MedicalVisit with id {organ_system_review_id} does not exist")
+
+            if soft_delete:
+                existing_organ_system_review.is_active = False
+                session.add(existing_organ_system_review)
+            else:
+                session.delete(existing_organ_system_review)
+
+            session.commit()

healthdatalayer/repositories/medical_visit_repositories/physical_exam_repository.py

@@ -0,0 +1,89 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select, or_
+from sqlalchemy.orm import selectinload,joinedload
+from healthdatalayer.models import PhysicalExam
+from healthdatalayer.models import MedicalVisit
+from healthdatalayer.config.db import engines, get_session
+
+class PhysicalExamRepository:
+    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, physical_exam: PhysicalExam) -> PhysicalExam:
+        with get_session(self.tenant) as session:
+            session.add(physical_exam)
+            session.commit()
+            session.refresh(physical_exam)
+            return physical_exam
+    
+    def get_by_id_command(self, physical_exam_id: UUID, load_relations: bool = False) -> Optional[PhysicalExam]:
+        with get_session(self.tenant) as session:
+            
+            if load_relations:
+                statement = select(PhysicalExam).where(PhysicalExam.physical_exam_id == physical_exam_id).options(
+                    joinedload(PhysicalExam.medical_visit)
+                )
+                physical_exam = session.exec(statement).first()
+               
+                return physical_exam
+            else:
+                return session.get(PhysicalExam, physical_exam_id)
+    
+    def get_by_medical_visit_id_command(self, medical_visit_id: UUID, load_relations: bool = False) ->Optional[PhysicalExam]:
+        with get_session(self.tenant) as session:
+            
+            statement = select(PhysicalExam).where(PhysicalExam.medical_visit_id == medical_visit_id)
+            if load_relations:
+                statement = statement.options(
+                    joinedload(PhysicalExam.medical_visit)
+                )
+            physical_exam = session.exec(statement).first()
+            
+            return physical_exam 
+    
+    def get_all_command(self, active_only: bool = True,load_related: bool = False) -> List[PhysicalExam]:
+        with get_session(self.tenant) as session:
+            
+            statement = select(PhysicalExam)
+            
+            if load_related:
+                statement = select(PhysicalExam).options(
+                    selectinload(PhysicalExam.medical_visit)
+                )
+            
+            if active_only:
+                statement = statement.where(PhysicalExam.is_active == True)
+                physical_exam = session.exec(statement).all()
+                
+            return physical_exam
+        
+    def update_command(self, physical_exam: PhysicalExam) -> PhysicalExam:
+        with get_session(self.tenant) as session:
+            existing_physical_exam = session.get(PhysicalExam, physical_exam.physical_exam_id)
+            if not existing_physical_exam:
+                raise ValueError(f"triage with id {physical_exam.physical_exam_id} does not exist")
+            
+            for key, value in physical_exam.dict(exclude_unset=True).items():
+                setattr(existing_physical_exam, key, value)
+            
+            bd_physical_exam =  session.merge(existing_physical_exam)
+            session.commit()
+            session.refresh(bd_physical_exam)
+            return bd_physical_exam
+        
+    def delete_command(self, physical_exam_id: UUID, soft_delete: bool = False)->None:
+        with get_session(self.tenant) as session:
+            existing_physical_exam = session.get(PhysicalExam, physical_exam_id)
+            if not existing_physical_exam:
+                raise ValueError(f"MedicalVisit with id {physical_exam_id} does not exist")
+
+            if soft_delete:
+                existing_physical_exam.is_active = False
+                session.add(existing_physical_exam)
+            else:
+                session.delete(existing_physical_exam)
+
+            session.commit()

healthdatalayer/repositories/medical_visit_repositories/visit_triage_repository.py

@@ -0,0 +1,95 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+from sqlalchemy.orm import selectinload,joinedload
+from healthdatalayer.models import VisitTriage
+from healthdatalayer.models import MedicalVisit
+from healthdatalayer.config.db import engines, get_session
+
+class VisitTriageRepository:
+    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, visit_triage: VisitTriage) -> VisitTriage:
+        with get_session(self.tenant) as session:
+            session.add(visit_triage)
+            session.commit()
+            session.refresh(visit_triage)
+            return visit_triage
+
+    def get_by_id_command(self, visit_triage_id: UUID, load_relations: bool = False) -> Optional[VisitTriage]:
+        with get_session(self.tenant) as session:
+            
+            if load_relations:
+                statement = select(VisitTriage).where(VisitTriage.visit_triage_id == visit_triage_id).options(
+                    joinedload(VisitTriage.medical_visit)
+                )
+                visit_triage = session.exec(statement).first()
+               
+                return visit_triage
+            else:
+                return session.get(VisitTriage, visit_triage_id)
+    
+    def get_by_medical_visit_id_command(self, medical_visit_id: UUID, load_relations: bool = False) ->Optional[VisitTriage]:
+        with get_session(self.tenant) as session:
+            
+            statement = select(VisitTriage).where(VisitTriage.medical_visit_id == medical_visit_id)
+            if load_relations:
+                statement = statement.options(
+                    joinedload(VisitTriage.medical_visit)
+                )
+            visit_triage = session.exec(statement).first()
+            
+            return visit_triage 
+    
+    def get_all_command(self, active_only: bool = True,load_related: bool = False) -> List[VisitTriage]:
+        with get_session(self.tenant) as session:
+            
+            statement = select(VisitTriage)
+            
+            if load_related:
+                statement = select(VisitTriage).options(
+                    selectinload(VisitTriage.medical_visit)
+                )
+            
+            if active_only:
+                statement = statement.where(VisitTriage.is_active == True)
+                visit_triage = session.exec(statement).all()
+                
+            return visit_triage
+        
+    def update_command(self, visit_triage: VisitTriage) -> VisitTriage:
+        with get_session(self.tenant) as session:
+            existing_visit_triage = session.get(VisitTriage, visit_triage.visit_triage_id)
+            if not existing_visit_triage:
+                raise ValueError(f"triage with id {visit_triage.visit_triage_id} does not exist")
+            
+            for key, value in visit_triage.dict(exclude_unset=True).items():
+                setattr(existing_visit_triage, key, value)
+            
+            bd_visit_triage =  session.merge(existing_visit_triage)
+            session.commit()
+            session.refresh(bd_visit_triage)
+            return bd_visit_triage
+        
+    def delete_command(self, visit_triage_id: UUID, soft_delete: bool = False)->None:
+        with get_session(self.tenant) as session:
+            existing_visit_triage = session.get(MedicalVisit, visit_triage_id)
+            if not existing_visit_triage:
+                raise ValueError(f"MedicalVisit with id {visit_triage_id} does not exist")
+
+            if soft_delete:
+                existing_visit_triage.is_active = False
+                session.add(existing_visit_triage)
+            else:
+                session.delete(existing_visit_triage)
+
+            session.commit()
+
+    def exists_by_medical_visit_id_command(self, medical_visit_id: UUID) -> bool:
+        with get_session(self.tenant) as session:
+            statement = select(VisitTriage).where(VisitTriage.medical_visit_id == medical_visit_id)
+            result = session.exec(statement).first()
+            return result is not None

healthdatalayer/repositories/user_repositories/permission_repository.py

@@ -0,0 +1,238 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+from sqlalchemy.orm import selectinload
+
+from healthdatalayer.models import Permission
+from healthdatalayer.models import Role
+from healthdatalayer.models import User
+from healthdatalayer.config.db import engines, get_session
+
+class PermissionRepository:
+    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, permission: Permission) -> Permission:
+        with get_session(self.tenant) as session:
+            session.add(permission)
+            session.commit()
+            session.refresh(permission)
+            return permission
+
+    def get_by_id_command(self, permission_id: UUID, load_relations: bool = False) -> Optional[Permission]:
+        with get_session(self.tenant) as session:
+            if load_relations:
+                statement = select(Permission).where(Permission.permission_id == permission_id).options(
+                    selectinload(Permission.roles),
+                    selectinload(Permission.users)
+                )
+                return session.exec(statement).first()
+            else:
+                return session.get(Permission, permission_id)
+
+    def get_by_name_command(self, name: str, load_relations: bool = False) -> Optional[Permission]:
+        with get_session(self.tenant) as session:
+            statement = select(Permission).where(Permission.name == name)
+            
+            if load_relations:
+                statement = statement.options(
+                    selectinload(Permission.roles),
+                    selectinload(Permission.users)
+                )
+            
+            return session.exec(statement).first()
+
+    def search_by_name_command(self, name: str, load_relations: bool = False) -> List[Permission]:
+        with get_session(self.tenant) as session:
+            statement = select(Permission).where(Permission.name.ilike(f"%{name}%"))
+            
+            if load_relations:
+                statement = statement.options(
+                    selectinload(Permission.roles),
+                    selectinload(Permission.users)
+                )
+            
+            results = session.exec(statement)
+            return results.all()
+
+    def list_all_command(self, active_only: bool = True, load_relations: bool = False) -> List[Permission]:
+        with get_session(self.tenant) as session:
+            statement = select(Permission)
+            
+            if active_only:
+                statement = statement.where(Permission.is_active == True)
+            
+            if load_relations:
+                statement = statement.options(
+                    selectinload(Permission.roles),
+                    selectinload(Permission.users)
+                )
+            
+            results = session.exec(statement)
+            return results.all()
+
+    def update_command(self, permission: Permission) -> Permission:
+        with get_session(self.tenant) as session:
+            db_permission = session.merge(permission)
+            session.commit()
+            session.refresh(db_permission)
+            return db_permission
+
+    def delete_command(self, permission_id: UUID, soft_delete: bool = True) -> bool:
+        with get_session(self.tenant) as session:
+            db_permission = session.get(Permission, permission_id)
+            if not db_permission:
+                return False
+            
+            if soft_delete:
+                db_permission.is_active = False
+                session.add(db_permission)
+            else:
+                session.delete(db_permission)
+            
+            session.commit()
+            return True
+
+    def count_command(self, active_only: bool = True) -> int:
+        with get_session(self.tenant) as session:
+            statement = select(Permission)
+            if active_only:
+                statement = statement.where(Permission.is_active == True)
+            results = session.exec(statement)
+            return len(results.all())
+
+    def exists_by_name_command(self, name: str) -> bool:
+        with get_session(self.tenant) as session:
+            statement = select(Permission).where(Permission.name == name)
+            result = session.exec(statement).first()
+            return result is not None
+        
+    # ROLE COMMANDS    
+
+    def get_permission_roles_command(self, permission_id: UUID) -> List[Role]:
+        with get_session(self.tenant) as session:
+            statement = select(Permission).options(selectinload(Permission.roles)).where(
+                Permission.permission_id == permission_id
+            )
+            permission = session.exec(statement).first()
+            if not permission:
+                return []
+            return permission.roles
+    
+    def assign_to_role_command(self, permission_id: UUID, role_id: UUID) -> Optional[Permission]:
+        with get_session(self.tenant) as session:
+            permission_statement = select(Permission).options(selectinload(Permission.roles)).where(
+                Permission.permission_id == permission_id
+            )
+            permission = session.exec(permission_statement).first()
+            if not permission:
+                return None
+            
+            role = session.get(Role, role_id)
+            if not role:
+                return None
+            
+            if role not in permission.roles:
+                permission.roles.append(role)
+                session.add(permission)
+                session.commit()
+                session.refresh(permission)
+            
+            return permission
+
+    def remove_from_role_command(self, permission_id: UUID, role_id: UUID) -> Optional[Permission]:
+        with get_session(self.tenant) as session:
+            permission_statement = select(Permission).options(selectinload(Permission.roles)).where(
+                Permission.permission_id == permission_id
+            )
+            permission = session.exec(permission_statement).first()
+            if not permission:
+                return None
+            
+            role = session.get(Role, role_id)
+            if not role:
+                return None
+            
+            if role in permission.roles:
+                permission.roles.remove(role)
+                session.add(permission)
+                session.commit()
+                session.refresh(permission)
+            
+            return permission
+    
+    def is_assigned_to_role_command(self, permission_id: UUID, role_id: UUID) -> bool:
+        with get_session(self.tenant) as session:
+            statement = select(Permission).options(selectinload(Permission.roles)).where(
+                Permission.permission_id == permission_id
+            )
+            permission = session.exec(statement).first()
+            if not permission:
+                return False
+            return any(role.role_id == role_id for role in permission.roles)
+    
+    # USER COMMANDS    
+
+    def get_permission_users_command(self, permission_id: UUID) -> List[User]:
+        with get_session(self.tenant) as session:
+            statement = select(Permission).options(selectinload(Permission.users)).where(
+                Permission.permission_id == permission_id
+            )
+            permission = session.exec(statement).first()
+            if not permission:
+                return []
+            return permission.users
+
+    def assign_to_user_command(self, permission_id: UUID, user_id: UUID) -> Optional[Permission]:
+        with get_session(self.tenant) as session:
+            permission_statement = select(Permission).options(selectinload(Permission.users)).where(
+                Permission.permission_id == permission_id
+            )
+            permission = session.exec(permission_statement).first()
+            if not permission:
+                return None
+            
+            user = session.get(User, user_id)
+            if not user:
+                return None
+            
+            if user not in permission.users:
+                permission.users.append(user)
+                session.add(permission)
+                session.commit()
+                session.refresh(permission)
+            
+            return permission
+
+    def remove_from_user_command(self, permission_id: UUID, user_id: UUID) -> Optional[Permission]:
+        with get_session(self.tenant) as session:
+            permission_statement = select(Permission).options(selectinload(Permission.users)).where(
+                Permission.permission_id == permission_id
+            )
+            permission = session.exec(permission_statement).first()
+            if not permission:
+                return None
+            
+            user = session.get(User, user_id)
+            if not user:
+                return None
+            
+            if user in permission.users:
+                permission.users.remove(user)
+                session.add(permission)
+                session.commit()
+                session.refresh(permission)
+            
+            return permission
+
+    def is_assigned_to_user_command(self, permission_id: UUID, user_id: UUID) -> bool:
+        with get_session(self.tenant) as session:
+            statement = select(Permission).options(selectinload(Permission.users)).where(
+                Permission.permission_id == permission_id
+            )
+            permission = session.exec(statement).first()
+            if not permission:
+                return False
+            return any(user.user_id == user_id for user in permission.users)

healthdatalayer/repositories/user_repositories/role_repository.py

@@ -0,0 +1,174 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+from sqlalchemy.orm import selectinload
+
+from healthdatalayer.models import Role
+from healthdatalayer.models import Permission
+from healthdatalayer.models import User
+from healthdatalayer.config.db import engines, get_session
+
+class RoleRepository:
+    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, role: Role) -> Role:
+        with get_session(self.tenant) as session:
+            session.add(role)
+            session.commit()
+            session.refresh(role)
+            return role
+
+    def get_by_id_command(self, role_id: UUID, load_relations: bool = False) -> Optional[Role]:
+        with get_session(self.tenant) as session:
+            if load_relations:
+                statement = select(Role).where(Role.role_id == role_id).options(
+                    selectinload(Role.permissions),
+                    selectinload(Role.users)
+                )
+                return session.exec(statement).first()
+            else:
+                return session.get(Role, role_id)
+
+    def get_by_name_command(self, name: str, load_relations: bool = False) -> Optional[Role]:
+        with get_session(self.tenant) as session:
+            statement = select(Role).where(Role.name == name)
+            
+            if load_relations:
+                statement = statement.options(
+                    selectinload(Role.permissions),
+                    selectinload(Role.users)
+                )
+            
+            return session.exec(statement).first()
+
+    def search_by_name_command(self, name: str, load_relations: bool = False) -> List[Role]:
+        with get_session(self.tenant) as session:
+            statement = select(Role).where(Role.name.ilike(f"%{name}%"))
+            
+            if load_relations:
+                statement = statement.options(
+                    selectinload(Role.permissions),
+                    selectinload(Role.users)
+                )
+            
+            results = session.exec(statement)
+            return results.all()
+
+    def list_all_command(self, active_only: bool = True, load_relations: bool = False) -> List[Role]:
+        with get_session(self.tenant) as session:
+            statement = select(Role)
+            
+            if active_only:
+                statement = statement.where(Role.is_active == True)
+            
+            if load_relations:
+                statement = statement.options(
+                    selectinload(Role.permissions),
+                    selectinload(Role.users)
+                )
+            
+            results = session.exec(statement)
+            return results.all()
+
+    def update_command(self, role: Role) -> Role:
+        with get_session(self.tenant) as session:
+            db_role = session.merge(role)
+            session.commit()
+            session.refresh(db_role)
+            return db_role
+
+    def delete_command(self, role_id: UUID, soft_delete: bool = True) -> bool:
+        with get_session(self.tenant) as session:
+            db_role = session.get(Role, role_id)
+            if not db_role:
+                return False
+            
+            if soft_delete:
+                db_role.is_active = False
+                session.add(db_role)
+            else:
+                session.delete(db_role)
+            
+            session.commit()
+            return True
+
+    def count_command(self, active_only: bool = True) -> int:
+        with get_session(self.tenant) as session:
+            statement = select(Role)
+            if active_only:
+                statement = statement.where(Role.is_active == True)
+            results = session.exec(statement)
+            return len(results.all())
+
+    def exists_by_name_command(self, name: str) -> bool:
+        with get_session(self.tenant) as session:
+            statement = select(Role).where(Role.name == name)
+            result = session.exec(statement).first()
+            return result is not None
+        
+    # RELATIONS COMMANDS
+
+    def get_role_permissions_command(self, role_id: UUID) -> List[Permission]:
+        with get_session(self.tenant) as session:
+            statement = select(Role).options(selectinload(Role.permissions)).where(Role.role_id == role_id)
+            role = session.exec(statement).first()
+            if not role:
+                return []
+            return role.permissions
+
+    def get_role_users_command(self, role_id: UUID) -> List[User]:
+        with get_session(self.tenant) as session:
+            statement = select(Role).options(selectinload(Role.users)).where(Role.role_id == role_id)
+            role = session.exec(statement).first()
+            if not role:
+                return []
+            return role.users
+
+    def assign_permission_command(self, role_id: UUID, permission_id: UUID) -> Optional[Role]:
+        with get_session(self.tenant) as session:
+            role_statement = select(Role).options(selectinload(Role.permissions)).where(Role.role_id == role_id)
+            role = session.exec(role_statement).first()
+            if not role:
+                return None
+            
+            permission = session.get(Permission, permission_id)
+            if not permission:
+                return None
+            
+            if permission not in role.permissions:
+                role.permissions.append(permission)
+                session.add(role)
+                session.commit()
+                session.refresh(role)
+            
+            return role
+
+    def remove_permission_command(self, role_id: UUID, permission_id: UUID) -> Optional[Role]:
+        with get_session(self.tenant) as session:
+            role_statement = select(Role).options(selectinload(Role.permissions)).where(Role.role_id == role_id)
+            role = session.exec(role_statement).first()
+            if not role:
+                return None
+            
+            permission = session.get(Permission, permission_id)
+            if not permission:
+                return None
+            
+            if permission in role.permissions:
+                role.permissions.remove(permission)
+                session.add(role)
+                session.commit()
+                session.refresh(role)
+            
+            return role
+
+    def has_permission_command(self, role_id: UUID, permission_name: str) -> bool:
+        with get_session(self.tenant) as session:
+            statement = select(Role).options(selectinload(Role.permissions)).where(Role.role_id == role_id)
+            role = session.exec(statement).first()
+            if not role:
+                return False
+            return any(perm.name == permission_name for perm in role.permissions)