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

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 models import Role
+from models import Permission
+from models import User
+from 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)

repositories/user_repositories/user_repository.py

@@ -0,0 +1,251 @@
+from typing import Optional, List
+from uuid import UUID
+from sqlmodel import select
+from sqlalchemy.orm import selectinload
+
+from models import User
+from models import Role
+from models import Permission
+from config.db import engines, get_session
+
+class UserRepository:
+    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, user: User) -> User:
+        with get_session(self.tenant) as session:
+            session.add(user)
+            session.commit()
+            session.refresh(user)
+            return user
+
+    def get_by_id_command(self, user_id: UUID, load_relations: bool = False) -> Optional[User]:
+        with get_session(self.tenant) as session:
+            if load_relations:
+                statement = select(User).where(User.user_id == user_id).options(
+                    selectinload(User.roles),
+                    selectinload(User.permissions)
+                )
+                return session.exec(statement).first()
+            else:
+                return session.get(User, user_id)
+
+    def get_by_username_command(self, username: str, load_relations: bool = False) -> Optional[User]:
+        with get_session(self.tenant) as session:
+            statement = select(User).where(User.username == username)
+            
+            if load_relations:
+                statement = statement.options(
+                    selectinload(User.roles),
+                    selectinload(User.permissions)
+                )
+            
+            return session.exec(statement).first()
+
+    def get_by_email_command(self, email: str, load_relations: bool = False) -> Optional[User]:
+        with get_session(self.tenant) as session:
+            statement = select(User).where(User.email == email)
+            
+            if load_relations:
+                statement = statement.options(
+                    selectinload(User.roles),
+                    selectinload(User.permissions)
+                )
+            
+            return session.exec(statement).first()
+
+    def search_by_username_command(self, username: str, load_relations: bool = False) -> List[User]:
+        with get_session(self.tenant) as session:
+            statement = select(User).where(User.username.ilike(f"%{username}%"))
+            
+            if load_relations:
+                statement = statement.options(
+                    selectinload(User.roles),
+                    selectinload(User.permissions)
+                )
+            
+            results = session.exec(statement)
+            return results.all()
+
+    def list_all_command(self, active_only: bool = True, load_relations: bool = False) -> List[User]:
+        with get_session(self.tenant) as session:
+            statement = select(User)
+            
+            if active_only:
+                statement = statement.where(User.is_active == True)
+            
+            if load_relations:
+                statement = statement.options(
+                    selectinload(User.roles),
+                    selectinload(User.permissions)
+                )
+            
+            results = session.exec(statement)
+            return results.all()
+
+    def update_command(self, user: User) -> User:
+        with get_session(self.tenant) as session:
+            db_user = session.merge(user)
+            session.commit()
+            session.refresh(db_user)
+            return db_user
+
+    def delete_command(self, user_id: UUID, soft_delete: bool = True) -> bool:
+        with get_session(self.tenant) as session:
+            db_user = session.get(User, user_id)
+            if not db_user:
+                return False
+            
+            if soft_delete:
+                db_user.is_active = False
+                session.add(db_user)
+            else:
+                session.delete(db_user)
+            
+            session.commit()
+            return True
+
+    def count_command(self, active_only: bool = True) -> int:
+        with get_session(self.tenant) as session:
+            statement = select(User)
+            if active_only:
+                statement = statement.where(User.is_active == True)
+            results = session.exec(statement)
+            return len(results.all())
+
+    def exists_by_username_command(self, username: str) -> bool:
+        with get_session(self.tenant) as session:
+            statement = select(User).where(User.username == username)
+            result = session.exec(statement).first()
+            return result is not None
+
+    def exists_by_email_command(self, email: str) -> bool:
+        with get_session(self.tenant) as session:
+            statement = select(User).where(User.email == email)
+            result = session.exec(statement).first()
+            return result is not None
+
+    def change_password_command(self, user_id: UUID, new_password: str) -> Optional[User]:
+        with get_session(self.tenant) as session:
+            user = session.get(User, user_id)
+            if not user:
+                return None
+            user.password = new_password
+            session.add(user)
+            session.commit()
+            session.refresh(user)
+            return user
+        
+    # ROLES COMANDS
+
+    def get_user_roles_command(self, user_id: UUID) -> List[Role]:
+        with get_session(self.tenant) as session:
+            statement = select(User).options(selectinload(User.roles)).where(User.user_id == user_id)
+            user = session.exec(statement).first()
+            if not user:
+                return []
+            return user.roles
+    
+    def has_role_command(self, user_id: UUID, role_name: str) -> bool:
+        with get_session(self.tenant) as session:
+            statement = select(User).options(selectinload(User.roles)).where(User.user_id == user_id)
+            user = session.exec(statement).first()
+            if not user:
+                return False
+            return any(role.name == role_name for role in user.roles)
+    
+    def assign_role_command(self, user_id: UUID, role_id: UUID) -> Optional[User]:
+        with get_session(self.tenant) as session:
+            user_statement = select(User).options(selectinload(User.roles)).where(User.user_id == user_id)
+            user = session.exec(user_statement).first()
+            if not user:
+                return None
+            
+            role = session.get(Role, role_id)
+            if not role:
+                return None
+            
+            if role not in user.roles:
+                user.roles.append(role)
+                session.add(user)
+                session.commit()
+                session.refresh(user)
+            
+            return user
+
+    def remove_role_command(self, user_id: UUID, role_id: UUID) -> Optional[User]:
+        with get_session(self.tenant) as session:
+            user_statement = select(User).options(selectinload(User.roles)).where(User.user_id == user_id)
+            user = session.exec(user_statement).first()
+            if not user:
+                return None
+            
+            role = session.get(Role, role_id)
+            if not role:
+                return None
+            
+            if role in user.roles:
+                user.roles.remove(role)
+                session.add(user)
+                session.commit()
+                session.refresh(user)
+            
+            return user
+        
+    # PERMISSIONS COMANDS
+
+    def get_user_permissions_command(self, user_id: UUID) -> List[Permission]:
+        with get_session(self.tenant) as session:
+            statement = select(User).options(selectinload(User.permissions)).where(User.user_id == user_id)
+            user = session.exec(statement).first()
+            if not user:
+                return []
+            return user.permissions
+
+    def has_permission_command(self, user_id: UUID, permission_name: str) -> bool:
+        with get_session(self.tenant) as session:
+            statement = select(User).options(selectinload(User.permissions)).where(User.user_id == user_id)
+            user = session.exec(statement).first()
+            if not user:
+                return False
+            return any(perm.name == permission_name for perm in user.permissions)
+
+    def assign_permission_command(self, user_id: UUID, permission_id: UUID) -> Optional[User]:
+        with get_session(self.tenant) as session:
+            user_statement = select(User).options(selectinload(User.permissions)).where(User.user_id == user_id)
+            user = session.exec(user_statement).first()
+            if not user:
+                return None
+            
+            permission = session.get(Permission, permission_id)
+            if not permission:
+                return None
+            
+            if permission not in user.permissions:
+                user.permissions.append(permission)
+                session.add(user)
+                session.commit()
+                session.refresh(user)
+            
+            return user
+
+    def remove_permission_command(self, user_id: UUID, permission_id: UUID) -> Optional[User]:
+        with get_session(self.tenant) as session:
+            user_statement = select(User).options(selectinload(User.permissions)).where(User.user_id == user_id)
+            user = session.exec(user_statement).first()
+            if not user:
+                return None
+            
+            permission = session.get(Permission, permission_id)
+            if not permission:
+                return None
+            
+            if permission in user.permissions:
+                user.permissions.remove(permission)
+                session.add(user)
+                session.commit()
+                session.refresh(user)
+            
+            return user

healthdatalayer-1.0.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-config/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-config/config.py,sha256=vyqrlHDgCGpYX7V9fDn4g671lUU1RuWlSYCIazI-SqQ,689
-config/db.py,sha256=b_SWTINJSVUhR0uyD4h93jPLKUzRm6Ky0tmALWbjM18,342
-config/vault.py,sha256=9yUMXjaTYSnqr0npcQXDsg6Z7G3DityqpmHl1x42zS0,748
-models/__init__.py,sha256=aHts_4fmmSgAGlKe-qZ9aCXjeYPBVaB-VM4LqH-y4_4,1994
-repositories/__init__.py,sha256=b8ya7gJkFq0yzF3h8G0vIiakv_uOB9u859sdBLhEZHI,2504
-healthdatalayer-1.0.1.dist-info/METADATA,sha256=Y2pz-zYnb_EGOLcA3_QBb0Jo03RCKu_ZC9XyJZgci-c,827
-healthdatalayer-1.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-healthdatalayer-1.0.1.dist-info/top_level.txt,sha256=S84RTy7EJk7BqzfUpsghy7n19iFi9FVqXgHKlv68GPI,27
-healthdatalayer-1.0.1.dist-info/RECORD,,