zrb 1.0.0a20__py3-none-any.whl → 1.0.0b3__py3-none-any.whl

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/route.py

@@ -1,8 +1,11 @@
 from fastapi import FastAPI
-from my_app_name.common.app import app
+from my_app_name.common.app_factory import app
 from my_app_name.common.schema import BasicResponse
 from my_app_name.config import APP_MAIN_MODULE, APP_MODE, APP_MODULES
-from my_app_name.module.auth.service.user.user_usecase_factory import user_usecase
+from my_app_name.module.auth.service.permission.permission_service_factory import (
+    permission_service,
+)
+from my_app_name.module.auth.service.user.user_service_factory import user_service
 
 
 def serve_health_check(app: FastAPI):
@@ -31,7 +34,8 @@ def serve_route(app: FastAPI):
         serve_readiness_check(app)
 
     # Serve user endpoints for APIClient
-    user_usecase.serve_route(app)
+    user_service.serve_route(app)
+    permission_service.serve_route(app)
 
 
 serve_route(app)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/permission/permission_service.py

@@ -0,0 +1,117 @@
+from logging import Logger
+
+from my_app_name.common.base_service import BaseService
+from my_app_name.module.auth.service.permission.repository.permission_repository import (
+    PermissionRepository,
+)
+from my_app_name.schema.permission import (
+    MultiplePermissionResponse,
+    PermissionCreateWithAudit,
+    PermissionResponse,
+    PermissionUpdateWithAudit,
+)
+
+
+class PermissionService(BaseService):
+
+    def __init__(self, logger: Logger, permission_repository: PermissionRepository):
+        super().__init__(logger)
+        self.permission_repository = permission_repository
+
+    @BaseService.route(
+        "/api/v1/permissions/{permission_id}",
+        methods=["get"],
+        response_model=PermissionResponse,
+    )
+    async def get_permission_by_id(self, permission_id: str) -> PermissionResponse:
+        return await self.permission_repository.get_by_id(permission_id)
+
+    @BaseService.route(
+        "/api/v1/permissions",
+        methods=["get"],
+        response_model=MultiplePermissionResponse,
+    )
+    async def get_permissions(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        sort: str | None = None,
+        filter: str | None = None,
+    ) -> MultiplePermissionResponse:
+        permissions = await self.permission_repository.get(
+            page, page_size, filter, sort
+        )
+        count = await self.permission_repository.count(filter)
+        return MultiplePermissionResponse(data=permissions, count=count)
+
+    @BaseService.route(
+        "/api/v1/permissions/bulk",
+        methods=["post"],
+        response_model=list[PermissionResponse],
+    )
+    async def create_permission_bulk(
+        self, data: list[PermissionCreateWithAudit]
+    ) -> list[PermissionResponse]:
+        permissions = await self.permission_repository.create_bulk(data)
+        return await self.permission_repository.get_by_ids(
+            [permission.id for permission in permissions]
+        )
+
+    @BaseService.route(
+        "/api/v1/permissions",
+        methods=["post"],
+        response_model=PermissionResponse,
+    )
+    async def create_permission(
+        self, data: PermissionCreateWithAudit
+    ) -> PermissionResponse:
+        permission = await self.permission_repository.create(data)
+        return await self.permission_repository.get_by_id(permission.id)
+
+    @BaseService.route(
+        "/api/v1/permissions/bulk",
+        methods=["put"],
+        response_model=PermissionResponse,
+    )
+    async def update_permission_bulk(
+        self, permission_ids: list[str], data: PermissionUpdateWithAudit
+    ) -> PermissionResponse:
+        permissions = await self.permission_repository.update_bulk(permission_ids, data)
+        return await self.permission_repository.get_by_ids(
+            [permission.id for permission in permissions]
+        )
+
+    @BaseService.route(
+        "/api/v1/permissions/{permission_id}",
+        methods=["put"],
+        response_model=PermissionResponse,
+    )
+    async def update_permission(
+        self, permission_id: str, data: PermissionUpdateWithAudit
+    ) -> PermissionResponse:
+        permission = await self.permission_repository.update(permission_id, data)
+        return await self.permission_repository.get_by_id(permission.id)
+
+    @BaseService.route(
+        "/api/v1/permissions/{permission_id}",
+        methods=["delete"],
+        response_model=PermissionResponse,
+    )
+    async def delete_permission_bulk(
+        self, permission_ids: list[str], deleted_by: str
+    ) -> PermissionResponse:
+        permissions = await self.permission_repository.delete_bulk(permission_ids)
+        return await self.permission_repository.get_by_ids(
+            [permission.id for permission in permissions]
+        )
+
+    @BaseService.route(
+        "/api/v1/permissions/{permission_id}",
+        methods=["delete"],
+        response_model=PermissionResponse,
+    )
+    async def delete_permission(
+        self, permission_id: str, deleted_by: str
+    ) -> PermissionResponse:
+        permission = await self.permission_repository.delete(permission_id)
+        return await self.permission_repository.get_by_id(permission.id)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/permission/permission_service_factory.py

@@ -0,0 +1,11 @@
+from my_app_name.common.logger_factory import logger
+from my_app_name.module.auth.service.permission.permission_service import (
+    PermissionService,
+)
+from my_app_name.module.auth.service.permission.repository.permission_repository_factory import (
+    permission_repository,
+)
+
+permission_service = PermissionService(
+    logger, permission_repository=permission_repository
+)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/permission/repository/permission_db_repository.py

@@ -0,0 +1,26 @@
+from my_app_name.common.base_db_repository import BaseDBRepository
+from my_app_name.module.auth.service.permission.repository.permission_repository import (
+    PermissionRepository,
+)
+from my_app_name.schema.permission import (
+    Permission,
+    PermissionCreateWithAudit,
+    PermissionResponse,
+    PermissionUpdateWithAudit,
+)
+
+
+class PermissionDBRepository(
+    BaseDBRepository[
+        Permission,
+        PermissionResponse,
+        PermissionCreateWithAudit,
+        PermissionUpdateWithAudit,
+    ],
+    PermissionRepository,
+):
+    db_model = Permission
+    response_model = PermissionResponse
+    create_model = PermissionCreateWithAudit
+    update_model = PermissionUpdateWithAudit
+    entity_name = "permission"

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/permission/repository/permission_repository.py

@@ -0,0 +1,61 @@
+from abc import ABC, abstractmethod
+
+from my_app_name.schema.permission import (
+    Permission,
+    PermissionCreateWithAudit,
+    PermissionResponse,
+    PermissionUpdateWithAudit,
+)
+
+
+class PermissionRepository(ABC):
+
+    @abstractmethod
+    async def get_by_id(self, id: str) -> PermissionResponse:
+        """Get permission by id"""
+
+    @abstractmethod
+    async def get_by_ids(self, id_list: list[str]) -> PermissionResponse:
+        """Get permissions by ids"""
+
+    @abstractmethod
+    async def get(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        filter: str | None = None,
+        sort: str | None = None,
+    ) -> list[Permission]:
+        """Get permissions by filter and sort"""
+
+    @abstractmethod
+    async def count(self, filter: str | None = None) -> int:
+        """Count permissions by filter"""
+
+    @abstractmethod
+    async def create(self, data: PermissionCreateWithAudit) -> Permission:
+        """Create a new permission"""
+
+    @abstractmethod
+    async def create_bulk(
+        self, data: list[PermissionCreateWithAudit]
+    ) -> list[Permission]:
+        """Create some permissions"""
+
+    @abstractmethod
+    async def delete(self, id: str) -> Permission:
+        """Delete a permission"""
+
+    @abstractmethod
+    async def delete_bulk(self, id_list: list[str]) -> list[Permission]:
+        """Delete some permissions"""
+
+    @abstractmethod
+    async def update(self, id: str, data: PermissionUpdateWithAudit) -> Permission:
+        """Update a permission"""
+
+    @abstractmethod
+    async def update_bulk(
+        self, id_list: list[str], data: PermissionUpdateWithAudit
+    ) -> list[Permission]:
+        """Update some permissions"""

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/permission/repository/permission_repository_factory.py

@@ -0,0 +1,13 @@
+from my_app_name.common.db_engine_factory import db_engine
+from my_app_name.config import APP_REPOSITORY_TYPE
+from my_app_name.module.auth.service.permission.repository.permission_db_repository import (
+    PermissionDBRepository,
+)
+from my_app_name.module.auth.service.permission.repository.permission_repository import (
+    PermissionRepository,
+)
+
+if APP_REPOSITORY_TYPE == "db":
+    permission_repository: PermissionRepository = PermissionDBRepository(db_engine)
+else:
+    permission_repository: PermissionRepository = None

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/role/repository/role_db_repository.py

@@ -0,0 +1,89 @@
+import datetime
+from typing import Any
+
+import ulid
+from my_app_name.common.base_db_repository import BaseDBRepository
+from my_app_name.module.auth.service.role.repository.role_repository import (
+    RoleRepository,
+)
+from my_app_name.schema.permission import Permission
+from my_app_name.schema.role import (
+    Role,
+    RoleCreateWithAudit,
+    RolePermission,
+    RoleResponse,
+    RoleUpdateWithAudit,
+)
+from sqlalchemy.sql import Select
+from sqlmodel import delete, insert, select
+
+
+class RoleDBRepository(
+    BaseDBRepository[
+        Role,
+        RoleResponse,
+        RoleCreateWithAudit,
+        RoleUpdateWithAudit,
+    ],
+    RoleRepository,
+):
+    db_model = Role
+    response_model = RoleResponse
+    create_model = RoleCreateWithAudit
+    update_model = RoleUpdateWithAudit
+    entity_name = "role"
+
+    def _select(self) -> Select:
+        return (
+            select(Role, Permission)
+            .join(RolePermission, RolePermission.role_id == Role.id, isouter=True)
+            .join(
+                Permission, Permission.id == RolePermission.permission_id, isouter=True
+            )
+        )
+
+    def _rows_to_responses(self, rows: list[tuple[Any, ...]]) -> list[RoleResponse]:
+        role_map: dict[str, dict[str, Any]] = {}
+        role_permission_map: dict[str, list[str]] = {}
+        for role, permission in rows:
+            if role.id not in role_map:
+                role_map[role.id] = {"role": role, "permissions": []}
+                role_permission_map[role.id] = []
+            if (
+                permission is not None
+                and permission.id not in role_permission_map[role.id]
+            ):
+                role_permission_map[role.id].append(permission.id)
+                role_map[role.id]["permissions"].append(permission.model_dump())
+        return [
+            RoleResponse(**data["role"].model_dump(), permissions=data["permissions"])
+            for data in role_map.values()
+        ]
+
+    async def add_permissions(self, data: dict[str, list[str]], created_by: str):
+        now = datetime.datetime.now(datetime.timezone.utc)
+        data_dict_list: list[dict[str, Any]] = []
+        for role_id, permission_ids in data.items():
+            for permission_id in permission_ids:
+                data_dict_list.append(
+                    self._model_to_data_dict(
+                        RolePermission(
+                            id=ulid.new().str,
+                            role_id=role_id,
+                            permission_id=permission_id,
+                            created_at=now,
+                            created_by=created_by,
+                        )
+                    )
+                )
+        async with self._session_scope() as session:
+            await self._execute_statement(
+                session, insert(RolePermission).values(data_dict_list)
+            )
+
+    async def remove_all_permissions(self, role_ids: list[str] = []):
+        async with self._session_scope() as session:
+            await self._execute_statement(
+                session,
+                delete(RolePermission).where(RolePermission.role_id._in(role_ids)),
+            )

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/role/repository/role_repository.py

@@ -0,0 +1,67 @@
+from abc import ABC, abstractmethod
+
+from my_app_name.schema.role import (
+    Role,
+    RoleCreateWithAudit,
+    RoleResponse,
+    RoleUpdateWithAudit,
+)
+
+
+class RoleRepository(ABC):
+
+    @abstractmethod
+    async def get_by_id(self, id: str) -> RoleResponse:
+        """Get role by id"""
+
+    @abstractmethod
+    async def get_by_ids(self, id_list: list[str]) -> RoleResponse:
+        """Get roles by ids"""
+
+    @abstractmethod
+    async def add_permissions(self, data: dict[str, list[str]], created_by: str):
+        """Adding permissions to roles"""
+
+    @abstractmethod
+    async def remove_all_permissions(self, role_ids: list[str] = []):
+        """Remove permissions from roles"""
+
+    @abstractmethod
+    async def get(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        filter: str | None = None,
+        sort: str | None = None,
+    ) -> list[Role]:
+        """Get roles by filter and sort"""
+
+    @abstractmethod
+    async def count(self, filter: str | None = None) -> int:
+        """Count roles by filter"""
+
+    @abstractmethod
+    async def create(self, data: RoleCreateWithAudit) -> Role:
+        """Create a new role"""
+
+    @abstractmethod
+    async def create_bulk(self, data: list[RoleCreateWithAudit]) -> list[Role]:
+        """Create some roles"""
+
+    @abstractmethod
+    async def delete(self, id: str) -> Role:
+        """Delete a role"""
+
+    @abstractmethod
+    async def delete_bulk(self, id_list: list[str]) -> list[Role]:
+        """Delete some roles"""
+
+    @abstractmethod
+    async def update(self, id: str, data: RoleUpdateWithAudit) -> Role:
+        """Update a role"""
+
+    @abstractmethod
+    async def update_bulk(
+        self, id_list: list[str], data: RoleUpdateWithAudit
+    ) -> list[Role]:
+        """Update some roles"""

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/role/repository/role_repository_factory.py

@@ -0,0 +1,13 @@
+from my_app_name.common.db_engine_factory import db_engine
+from my_app_name.config import APP_REPOSITORY_TYPE
+from my_app_name.module.auth.service.role.repository.role_db_repository import (
+    RoleDBRepository,
+)
+from my_app_name.module.auth.service.role.repository.role_repository import (
+    RoleRepository,
+)
+
+if APP_REPOSITORY_TYPE == "db":
+    role_repository: RoleRepository = RoleDBRepository(db_engine)
+else:
+    role_repository: RoleRepository = None

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/role/role_service.py

@@ -0,0 +1,137 @@
+from logging import Logger
+
+from my_app_name.common.base_service import BaseService
+from my_app_name.module.auth.service.role.repository.role_repository import (
+    RoleRepository,
+)
+from my_app_name.schema.role import (
+    MultipleRoleResponse,
+    RoleCreateWithPermissionsAndAudit,
+    RoleResponse,
+    RoleUpdateWithPermissionsAndAudit,
+)
+
+
+class RoleService(BaseService):
+
+    def __init__(self, logger: Logger, role_repository: RoleRepository):
+        super().__init__(logger)
+        self.role_repository = role_repository
+
+    @BaseService.route(
+        "/api/v1/roles/{role_id}",
+        methods=["get"],
+        response_model=RoleResponse,
+    )
+    async def get_role_by_id(self, role_id: str) -> RoleResponse:
+        return await self.role_repository.get_by_id(role_id)
+
+    @BaseService.route(
+        "/api/v1/roles",
+        methods=["get"],
+        response_model=MultipleRoleResponse,
+    )
+    async def get_roles(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        sort: str | None = None,
+        filter: str | None = None,
+    ) -> MultipleRoleResponse:
+        roles = await self.role_repository.get(page, page_size, filter, sort)
+        count = await self.role_repository.count(filter)
+        return MultipleRoleResponse(data=roles, count=count)
+
+    @BaseService.route(
+        "/api/v1/roles/bulk",
+        methods=["post"],
+        response_model=list[RoleResponse],
+    )
+    async def create_role_bulk(
+        self, data: list[RoleCreateWithPermissionsAndAudit]
+    ) -> list[RoleResponse]:
+        permission_ids = [row.get_permission_ids() for row in data]
+        data = [row.get_role_create_with_audit() for row in data]
+        roles = await self.role_repository.create_bulk(data)
+        if len(roles) > 0:
+            created_by = roles[0].created_by
+            await self.role_repository.add_permissions(
+                data={role.id: permission_ids[i] for i, role in enumerate(roles)},
+                created_by=created_by,
+            )
+        return await self.role_repository.get_by_ids([role.id for role in roles])
+
+    @BaseService.route(
+        "/api/v1/roles",
+        methods=["post"],
+        response_model=RoleResponse,
+    )
+    async def create_role(
+        self, data: RoleCreateWithPermissionsAndAudit
+    ) -> RoleResponse:
+        permission_ids = data.get_permission_ids()
+        data = data.get_role_create_with_audit()
+        role = await self.role_repository.create(data)
+        await self.role_repository.add_permissions(
+            data={role.id: permission_ids}, created_by=role.created_by
+        )
+        return await self.role_repository.get_by_id(role.id)
+
+    @BaseService.route(
+        "/api/v1/roles/bulk",
+        methods=["put"],
+        response_model=RoleResponse,
+    )
+    async def update_role_bulk(
+        self, role_ids: list[str], data: RoleUpdateWithPermissionsAndAudit
+    ) -> RoleResponse:
+        permission_ids = [row.get_permission_ids() for row in data]
+        data = [row.get_role_update_with_audit() for row in data]
+        roles = await self.role_repository.update_bulk(role_ids, data)
+        if len(roles) > 0:
+            updated_by = roles[0].updated_by
+            await self.role_repository.remove_all_permissions(
+                [role.id for role in roles]
+            )
+            await self.role_repository.add_permissions(
+                data={role.id: permission_ids[i] for i, role in enumerate(roles)},
+                created_by=updated_by,
+            )
+        return await self.role_repository.get_by_ids([role.id for role in roles])
+
+    @BaseService.route(
+        "/api/v1/roles/{role_id}",
+        methods=["put"],
+        response_model=RoleResponse,
+    )
+    async def update_role(
+        self, role_id: str, data: RoleUpdateWithPermissionsAndAudit
+    ) -> RoleResponse:
+        permission_ids = data.get_permission_ids()
+        data = data.get_role_update_with_audit()
+        role = await self.role_repository.update(role_id, data)
+        await self.role_repository.remove_all_permissions([role.id])
+        await self.role_repository.add_permissions(
+            data={role.id: permission_ids}, created_by=role.updated_by
+        )
+        return await self.role_repository.get_by_id(role.id)
+
+    @BaseService.route(
+        "/api/v1/roles/{role_id}",
+        methods=["delete"],
+        response_model=RoleResponse,
+    )
+    async def delete_role_bulk(
+        self, role_ids: list[str], deleted_by: str
+    ) -> RoleResponse:
+        roles = await self.role_repository.delete_bulk(role_ids)
+        return await self.role_repository.get_by_ids([role.id for role in roles])
+
+    @BaseService.route(
+        "/api/v1/roles/{role_id}",
+        methods=["delete"],
+        response_model=RoleResponse,
+    )
+    async def delete_role(self, role_id: str, deleted_by: str) -> RoleResponse:
+        role = await self.role_repository.delete(role_id)
+        return await self.role_repository.get_by_id(role.id)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/role/role_service_factory.py

@@ -0,0 +1,7 @@
+from my_app_name.common.logger_factory import logger
+from my_app_name.module.auth.service.role.repository.role_repository_factory import (
+    role_repository,
+)
+from my_app_name.module.auth.service.role.role_service import RoleService
+
+role_service = RoleService(logger, role_repository=role_repository)