zrb 1.0.0a21__py3-none-any.whl → 1.0.0b2__py3-none-any.whl

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

@@ -0,0 +1,75 @@
+from typing import Any
+
+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 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.role_id, isouter=True)
+        )
+
+    def _rows_to_responses(self, rows: list[tuple[Role, Permission]]) -> RoleResponse:
+        role_map: dict[str, dict[str, Any]] = {}
+        for role, permission in rows:
+            if role.id not in role_map:
+                role_map[role.id] = {"role": role, "permissions": set()}
+            if permission:
+                role_map[role.id]["permissions"].add(permission)
+        return [
+            RoleResponse(
+                **data["role"].model_dump(), permissions=list(data["permissions"])
+            )
+            for data in role_map.values()
+        ]
+
+    async def add_permissions(self, role_id, permission_names: list[str]) -> Role:
+        # TODO: complete this
+        select_statement = self._select().where(self.db_model.id == role_id)
+        rows = await self._execute_select_statement(select_statement)
+        responses = self._rows_to_responses(rows)
+        return self._ensure_one(responses)
+
+    async def remove_permissions(self, role_id, permission_names: list[str]) -> Role:
+        # TODO: complete this
+        select_statement = self._select().where(self.db_model.id == role_id)
+        rows = await self._execute_select_statement(select_statement)
+        responses = self._rows_to_responses(rows)
+        return self._ensure_one(responses)
+
+
+def _remove_create_model_additional_property(
+    data: RoleCreateWithAudit,
+) -> RoleCreateWithAudit:
+    return RoleCreateWithAudit(
+        **{key: val for key, val in data.model_dump().items() if key != "permissions"}
+    )

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

@@ -0,0 +1,59 @@
+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 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,105 @@
+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,
+    RoleCreateWithAudit,
+    RoleResponse,
+    RoleUpdateWithAudit,
+)
+
+
+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",
+        methods=["post"],
+        response_model=RoleResponse,
+    )
+    async def create_role(self, data: RoleCreateWithAudit) -> RoleResponse:
+        role = await self.role_repository.create(data)
+        return await self.role_repository.get_by_id(role.id)
+
+    @BaseService.route(
+        "/api/v1/roles/bulk",
+        methods=["post"],
+        response_model=list[RoleResponse],
+    )
+    async def create_role_bulk(
+        self, data: list[RoleCreateWithAudit]
+    ) -> list[RoleResponse]:
+        roles = await self.role_repository.create_bulk(data)
+        return await self.role_repository.get_by_ids([role.id for role in roles])
+
+    @BaseService.route(
+        "/api/v1/roles/bulk",
+        methods=["put"],
+        response_model=RoleResponse,
+    )
+    async def update_role_bulk(
+        self, role_ids: list[str], data: RoleUpdateWithAudit
+    ) -> RoleResponse:
+        roles = await self.role_repository.update_bulk(role_ids, data)
+        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: RoleUpdateWithAudit
+    ) -> RoleResponse:
+        role = await self.role_repository.update(role_id, data)
+        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)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/user/repository/user_db_repository.py

@@ -1,17 +1,21 @@
+from typing import Any
+
 from my_app_name.common.base_db_repository import BaseDBRepository
-from my_app_name.common.error import NotFoundError
 from my_app_name.module.auth.service.user.repository.user_repository import (
     UserRepository,
 )
+from my_app_name.schema.permission import Permission
+from my_app_name.schema.role import Role, RolePermission
 from my_app_name.schema.user import (
     User,
     UserCreateWithAudit,
     UserResponse,
+    UserRole,
     UserUpdateWithAudit,
 )
 from passlib.context import CryptContext
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlmodel import Session, select
+from sqlalchemy.sql import Select
+from sqlmodel import select
 
 # Password hashing context
 pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
@@ -32,14 +36,39 @@ class UserDBRepository(
     entity_name = "user"
     column_preprocessors = {"password": hash_password}
 
+    def _select(self) -> Select:
+        return (
+            select(User, Role, Permission)
+            .join(UserRole, UserRole.user_id == User.id, isouter=True)
+            .join(Role, Role.id == UserRole.role_id, isouter=True)
+            .join(RolePermission, RolePermission.role_id == Role.id, isouter=True)
+            .join(Permission, Permission.id == RolePermission.role_id, isouter=True)
+        )
+
+    def _rows_to_responses(
+        self, rows: list[tuple[User, Role, Permission]]
+    ) -> UserResponse:
+        user_map: dict[str, dict[str, Any]] = {}
+        for user, role, permission in rows:
+            if user.id not in user_map:
+                user_map[user.id] = {"user": user, "roles": set(), "permissions": set()}
+            if role:
+                user_map[user.id]["roles"].add(role)
+            if permission:
+                user_map[user.id]["permissions"].add(permission)
+        return [
+            UserResponse(
+                **data["user"].model_dump(),
+                roles=list(data["roles"]),
+                permissions=list(data["permissions"])
+            )
+            for data in user_map.values()
+        ]
+
     async def get_by_credentials(self, username: str, password: str) -> UserResponse:
-        statement = select(User).where(User.username == username)
-        if self.is_async:
-            async with AsyncSession(self.engine) as session:
-                user = await session.exec(statement).first
-        else:
-            with Session(self.engine) as session:
-                user = session.exec(statement).first()
-        if not user or not pwd_context.verify(password, user.hashed_password):
-            raise NotFoundError(f"{self.entity_name} not found")
-        return self._to_response(user)
+        select_statement = self._select().where(
+            User.username == username, User.password == hash_password(password)
+        )
+        rows = await self._execute_select_statement(select_statement)
+        responses = self._rows_to_responses(rows)
+        return self._ensure_one(responses)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/user/repository/user_repository.py

@@ -9,34 +9,55 @@ from my_app_name.schema.user import (
 
 
 class UserRepository(ABC):
+
+    @abstractmethod
+    async def get_by_id(self, id: str) -> UserResponse:
+        """Get user by id"""
+
+    @abstractmethod
+    async def get_by_ids(self, id_list: list[str]) -> UserResponse:
+        """Get users by ids"""
+
+    @abstractmethod
+    async def get(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        filter: str | None = None,
+        sort: str | None = None,
+    ) -> list[User]:
+        """Get users by filter and sort"""
+
+    @abstractmethod
+    async def count(self, filter: str | None = None) -> int:
+        """Count users by filter"""
+
     @abstractmethod
-    async def create(self, user_data: UserCreateWithAudit) -> UserResponse:
-        pass
+    async def create(self, data: UserCreateWithAudit) -> User:
+        """Create a new user"""
 
     @abstractmethod
-    async def get_by_id(self, user_id: str) -> UserResponse:
-        pass
+    async def create_bulk(self, data: list[UserCreateWithAudit]) -> list[User]:
+        """Create some users"""
 
     @abstractmethod
-    async def get_all(self) -> list[User]:
-        pass
+    async def delete(self, id: str) -> User:
+        """Delete a user"""
 
     @abstractmethod
-    async def update(
-        self, user_id: str, user_data: UserUpdateWithAudit
-    ) -> UserResponse:
-        pass
+    async def delete_bulk(self, id_list: list[str]) -> list[User]:
+        """Delete some users"""
 
     @abstractmethod
-    async def delete(self, user_id: str) -> UserResponse:
-        pass
+    async def update(self, id: str, data: UserUpdateWithAudit) -> User:
+        """Update a user"""
 
     @abstractmethod
-    async def create_bulk(
-        self, user_data_list: list[UserCreateWithAudit]
-    ) -> list[UserResponse]:
-        pass
+    async def update_bulk(
+        self, id_list: list[str], data: UserUpdateWithAudit
+    ) -> list[User]:
+        """Update some users"""
 
     @abstractmethod
     async def get_by_credentials(self, username: str, password: str) -> UserResponse:
-        pass
+        """Get user by credential"""

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/user/repository/user_repository_factory.py

@@ -1,4 +1,4 @@
-from my_app_name.common.db_engine import engine
+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.user.repository.user_db_repository import (
     UserDBRepository,
@@ -8,6 +8,6 @@ from my_app_name.module.auth.service.user.repository.user_repository import (
 )
 
 if APP_REPOSITORY_TYPE == "db":
-    user_repository: UserRepository = UserDBRepository(engine)
+    user_repository: UserRepository = UserDBRepository(db_engine)
 else:
     user_repository: UserRepository = None

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/user/user_service.py

@@ -0,0 +1,105 @@
+from logging import Logger
+
+from my_app_name.common.base_service import BaseService
+from my_app_name.module.auth.service.user.repository.user_repository import (
+    UserRepository,
+)
+from my_app_name.schema.user import (
+    MultipleUserResponse,
+    UserCreateWithAudit,
+    UserResponse,
+    UserUpdateWithAudit,
+)
+
+
+class UserService(BaseService):
+
+    def __init__(self, logger: Logger, user_repository: UserRepository):
+        super().__init__(logger)
+        self.user_repository = user_repository
+
+    @BaseService.route(
+        "/api/v1/users/{user_id}",
+        methods=["get"],
+        response_model=UserResponse,
+    )
+    async def get_user_by_id(self, user_id: str) -> UserResponse:
+        return await self.user_repository.get_by_id(user_id)
+
+    @BaseService.route(
+        "/api/v1/users",
+        methods=["get"],
+        response_model=MultipleUserResponse,
+    )
+    async def get_users(
+        self,
+        page: int = 1,
+        page_size: int = 10,
+        sort: str | None = None,
+        filter: str | None = None,
+    ) -> MultipleUserResponse:
+        users = await self.user_repository.get(page, page_size, filter, sort)
+        count = await self.user_repository.count(filter)
+        return MultipleUserResponse(data=users, count=count)
+
+    @BaseService.route(
+        "/api/v1/users",
+        methods=["post"],
+        response_model=UserResponse,
+    )
+    async def create_user(self, data: UserCreateWithAudit) -> UserResponse:
+        user = await self.user_repository.create(data)
+        return await self.user_repository.get_by_id(user.id)
+
+    @BaseService.route(
+        "/api/v1/users/bulk",
+        methods=["post"],
+        response_model=list[UserResponse],
+    )
+    async def create_user_bulk(
+        self, data: list[UserCreateWithAudit]
+    ) -> list[UserResponse]:
+        users = await self.user_repository.create_bulk(data)
+        return await self.user_repository.get_by_ids([user.id for user in users])
+
+    @BaseService.route(
+        "/api/v1/users/bulk",
+        methods=["put"],
+        response_model=UserResponse,
+    )
+    async def update_user_bulk(
+        self, user_ids: list[str], data: UserUpdateWithAudit
+    ) -> UserResponse:
+        users = await self.user_repository.update_bulk(user_ids, data)
+        return await self.user_repository.get_by_ids([user.id for user in users])
+
+    @BaseService.route(
+        "/api/v1/users/{user_id}",
+        methods=["put"],
+        response_model=UserResponse,
+    )
+    async def update_user(
+        self, user_id: str, data: UserUpdateWithAudit
+    ) -> UserResponse:
+        user = await self.user_repository.update(user_id, data)
+        return await self.user_repository.get_by_id(user.id)
+
+    @BaseService.route(
+        "/api/v1/users/{user_id}",
+        methods=["delete"],
+        response_model=UserResponse,
+    )
+    async def delete_user_bulk(
+        self, user_ids: list[str], deleted_by: str
+    ) -> UserResponse:
+        users = await self.user_repository.delete_bulk(user_ids)
+        return await self.user_repository.get_by_ids([user.id for user in users])
+
+    @BaseService.route(
+        "/api/v1/users/{user_id}",
+        methods=["delete"],
+        response_model=UserResponse,
+    )
+    async def delete_user(self, user_id: str, deleted_by: str) -> UserResponse:
+        user = await self.user_repository.delete(user_id)
+        return await self.user_repository.get_by_id(user.id)

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/module/auth/service/user/user_service_factory.py

@@ -0,0 +1,7 @@
+from my_app_name.common.logger_factory import logger
+from my_app_name.module.auth.service.user.repository.user_repository_factory import (
+    user_repository,
+)
+from my_app_name.module.auth.service.user.user_service import UserService
+
+user_service = UserService(logger, user_repository=user_repository)

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

@@ -1,11 +1,42 @@
-from fastapi import FastAPI
-from my_app_name.common.app import app
+import os
+
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.exception_handlers import http_exception_handler
+from fastapi.responses import HTMLResponse
+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.config import (
+    APP_GATEWAY_VIEW_PATH,
+    APP_MAIN_MODULE,
+    APP_MODE,
+    APP_MODULES,
+)
 from my_app_name.module.gateway.subroute.auth import serve_auth_route
+from my_app_name.module.gateway.util.view import render, render_error
+
+
+def serve_route(app: FastAPI):
+    if APP_MODE != "monolith" and "gateway" not in APP_MODULES:
+        return
+    if APP_MODE == "monolith" or APP_MAIN_MODULE == "gateway":
+        _serve_health_check(app)
+        _serve_readiness_check(app)
+        _serve_homepage(app)
+        _handle_404(app)
+
+    # Serve auth routes
+    serve_auth_route(app)
 
 
-def serve_health_check(app: FastAPI):
+def _serve_homepage(app: FastAPI):
+    @app.get("/", include_in_schema=False)
+    def home_page():
+        return render(
+            view_path=os.path.join(APP_GATEWAY_VIEW_PATH, "content", "homepage.html")
+        )
+
+
+def _serve_health_check(app: FastAPI):
     @app.api_route("/health", methods=["GET", "HEAD"], response_model=BasicResponse)
     async def health():
         """
@@ -14,7 +45,7 @@ def serve_health_check(app: FastAPI):
         return BasicResponse(message="ok")
 
 
-def serve_readiness_check(app: FastAPI):
+def _serve_readiness_check(app: FastAPI):
     @app.api_route("/readiness", methods=["GET", "HEAD"], response_model=BasicResponse)
     async def readiness():
         """
@@ -23,15 +54,13 @@ def serve_readiness_check(app: FastAPI):
         return BasicResponse(message="ok")
 
 
-def serve_route(app: FastAPI):
-    if APP_MODE != "monolith" and "gateway" not in APP_MODULES:
-        return
-    if APP_MODE == "monolith" or APP_MAIN_MODULE == "gateway":
-        serve_health_check(app)
-        serve_readiness_check(app)
-
-    # Serve Auth Route
-    serve_auth_route(app)
+def _handle_404(app: FastAPI):
+    @app.exception_handler(404)
+    async def default_404(request: Request, exc: HTTPException) -> HTMLResponse:
+        if request.url.path.startswith("/api"):
+            # Re-raise the exception to let FastAPI handle it
+            return await http_exception_handler(request, exc)
+        return render_error(error_message="Not found", status_code=404)
 
 
 serve_route(app)