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

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

@@ -1,8 +1,11 @@
+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,
@@ -10,44 +13,93 @@ from my_app_name.schema.user import (
 
 
 class UserService(BaseService):
-    def __init__(self, user_repository: UserRepository):
-        super().__init__()
+
+    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
+        "/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=list[UserResponse]
+        "/api/v1/users",
+        methods=["get"],
+        response_model=MultipleUserResponse,
     )
-    async def get_all_users(self) -> list[UserResponse]:
-        return await self.user_repository.get_all()
+    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 | list[UserResponse],
+        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(
-        self, data: UserCreateWithAudit | list[UserCreateWithAudit]
-    ) -> UserResponse | list[UserResponse]:
-        if isinstance(data, UserCreateWithAudit):
-            return await self.user_repository.create(data)
-        return await self.user_repository.create_bulk(data)
+    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/{user_id}", methods=["put"], response_model=UserResponse
+        "/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:
-        return await self.user_repository.update(user_id, data)
+        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
+        "/api/v1/users/{user_id}",
+        methods=["delete"],
+        response_model=UserResponse,
     )
     async def delete_user(self, user_id: str, deleted_by: str) -> UserResponse:
-        return await self.user_repository.delete(user_id)
+        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

@@ -1,6 +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(user_repository=user_repository)
+user_service = UserService(logger, user_repository=user_repository)

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

@@ -3,7 +3,7 @@ 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 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_GATEWAY_VIEW_PATH,

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

@@ -1,44 +1,214 @@
 from fastapi import FastAPI
-from my_app_name.module.auth.client.factory import client as auth_client
+from my_app_name.module.auth.client.auth_client_factory import auth_client
+from my_app_name.schema.permission import (
+    MultiplePermissionResponse,
+    PermissionCreate,
+    PermissionResponse,
+    PermissionUpdate,
+)
+from my_app_name.schema.role import (
+    MultipleRoleResponse,
+    RoleCreate,
+    RoleResponse,
+    RoleUpdate,
+)
 from my_app_name.schema.user import (
+    MultipleUserResponse,
     UserCreate,
-    UserCreateWithAudit,
     UserResponse,
     UserUpdate,
-    UserUpdateWithAudit,
 )
 
 
 def serve_auth_route(app: FastAPI):
 
-    @app.get("/api/v1/users", response_model=list[UserResponse])
-    async def get_all_users() -> UserResponse:
-        return await auth_client.get_all_users()
+    # Permission routes
+
+    @app.get("/api/v1/permissions", response_model=MultiplePermissionResponse)
+    async def get_permissions(
+        page: int = 1,
+        page_size: int = 10,
+        sort: str | None = None,
+        filter: str | None = None,
+    ) -> MultiplePermissionResponse:
+        return await auth_client.get_permissions(
+            page=page, page_size=page_size, sort=sort, filter=filter
+        )
+
+    @app.get("/api/v1/permissions/{permission_id}", response_model=PermissionResponse)
+    async def get_permission_by_id(permission_id: str) -> PermissionResponse:
+        return await auth_client.get_permission_by_id(permission_id)
+
+    @app.post(
+        "/api/v1/permissions/bulk",
+        response_model=list[PermissionResponse],
+    )
+    async def create_permission_bulk(data: list[PermissionCreate]):
+        return await auth_client.create_permission(
+            [row.with_audit(created_by="system") for row in data]
+        )
+
+    @app.post(
+        "/api/v1/permissions",
+        response_model=PermissionResponse,
+    )
+    async def create_permission(data: PermissionCreate):
+        return await auth_client.create_permission(data.with_audit(created_by="system"))
+
+    @app.put(
+        "/api/v1/permissions/bulk",
+        response_model=list[PermissionResponse],
+    )
+    async def update_permission_bulk(permission_ids: list[str], data: PermissionUpdate):
+        return await auth_client.update_permission_bulk(
+            permission_ids, data.with_audit(updated_by="system")
+        )
+
+    @app.put(
+        "/api/v1/permissions/{permission_id}",
+        response_model=PermissionResponse,
+    )
+    async def update_permission(permission_id: str, data: PermissionUpdate):
+        return await auth_client.update_permission(data.with_audit(updated_by="system"))
+
+    @app.delete(
+        "/api/v1/permissions/bulk",
+        response_model=list[PermissionResponse],
+    )
+    async def delete_permission_bulk(permission_ids: list[str]):
+        return await auth_client.delete_permission_bulk(
+            permission_ids, deleted_by="system"
+        )
+
+    @app.delete(
+        "/api/v1/permissions/{permission_id}",
+        response_model=PermissionResponse,
+    )
+    async def delete_permission(permission_id: str):
+        return await auth_client.delete_permission(permission_id, deleted_by="system")
+
+    # Role routes
+
+    @app.get("/api/v1/roles", response_model=MultipleRoleResponse)
+    async def get_roles(
+        page: int = 1,
+        page_size: int = 10,
+        sort: str | None = None,
+        filter: str | None = None,
+    ) -> MultipleRoleResponse:
+        return await auth_client.get_roles(
+            page=page, page_size=page_size, sort=sort, filter=filter
+        )
+
+    @app.get("/api/v1/roles/{role_id}", response_model=RoleResponse)
+    async def get_role_by_id(role_id: str) -> RoleResponse:
+        return await auth_client.get_role_by_id(role_id)
+
+    @app.post(
+        "/api/v1/roles/bulk",
+        response_model=list[RoleResponse],
+    )
+    async def create_role_bulk(data: list[RoleCreate]):
+        return await auth_client.create_role(
+            [row.with_audit(created_by="system") for row in data]
+        )
+
+    @app.post(
+        "/api/v1/roles",
+        response_model=RoleResponse,
+    )
+    async def create_role(data: RoleCreate):
+        return await auth_client.create_role(data.with_audit(created_by="system"))
+
+    @app.put(
+        "/api/v1/roles/bulk",
+        response_model=list[RoleResponse],
+    )
+    async def update_role_bulk(role_ids: list[str], data: RoleUpdate):
+        return await auth_client.update_role_bulk(
+            role_ids, data.with_audit(updated_by="system")
+        )
+
+    @app.put(
+        "/api/v1/roles/{role_id}",
+        response_model=RoleResponse,
+    )
+    async def update_role(role_id: str, data: RoleUpdate):
+        return await auth_client.update_role(data.with_audit(updated_by="system"))
+
+    @app.delete(
+        "/api/v1/roles/bulk",
+        response_model=list[RoleResponse],
+    )
+    async def delete_role_bulk(role_ids: list[str]):
+        return await auth_client.delete_role_bulk(role_ids, deleted_by="system")
+
+    @app.delete(
+        "/api/v1/roles/{role_id}",
+        response_model=RoleResponse,
+    )
+    async def delete_role(role_id: str):
+        return await auth_client.delete_role(role_id, deleted_by="system")
+
+    # User routes
+
+    @app.get("/api/v1/users", response_model=MultipleUserResponse)
+    async def get_users(
+        page: int = 1,
+        page_size: int = 10,
+        sort: str | None = None,
+        filter: str | None = None,
+    ) -> MultipleUserResponse:
+        return await auth_client.get_users(
+            page=page, page_size=page_size, sort=sort, filter=filter
+        )
 
     @app.get("/api/v1/users/{user_id}", response_model=UserResponse)
     async def get_user_by_id(user_id: str) -> UserResponse:
         return await auth_client.get_user_by_id(user_id)
 
-    @app.post("/api/v1/users", response_model=UserResponse | list[UserResponse])
-    async def create_user(data: UserCreate | list[UserCreate]):
-        if isinstance(data, UserCreate):
-            data_dict = data.model_dump(exclude_unset=True)
-            audited_data = UserCreateWithAudit(**data_dict, created_by="system")
-            return await auth_client.create_user(audited_data)
-        audited_data = [
-            UserCreateWithAudit(
-                **row.model_dump(exclude_unset=True), created_by="system"
-            )
-            for row in data
-        ]
-        return await auth_client.create_user(audited_data)
-
-    @app.put("/api/v1/users/{user_id}", response_model=UserResponse)
-    async def update_user(user_id: str, data: UserUpdate) -> UserResponse:
-        data_dict = data.model_dump(exclude_unset=True)
-        audited_data = UserUpdateWithAudit(**data_dict, updated_by="system")
-        return await auth_client.update_user(user_id, audited_data)
-
-    @app.delete("/api/v1/users/{user_id}", response_model=UserResponse)
-    async def delete_user(user_id: str) -> UserResponse:
+    @app.post(
+        "/api/v1/users/bulk",
+        response_model=list[UserResponse],
+    )
+    async def create_user_bulk(data: list[UserCreate]):
+        return await auth_client.create_user(
+            [row.with_audit(created_by="system") for row in data]
+        )
+
+    @app.post(
+        "/api/v1/users",
+        response_model=UserResponse,
+    )
+    async def create_user(data: UserCreate):
+        return await auth_client.create_user(data.with_audit(created_by="system"))
+
+    @app.put(
+        "/api/v1/users/bulk",
+        response_model=list[UserResponse],
+    )
+    async def update_user_bulk(user_ids: list[str], data: UserUpdate):
+        return await auth_client.update_user_bulk(
+            user_ids, data.with_audit(updated_by="system")
+        )
+
+    @app.put(
+        "/api/v1/users/{user_id}",
+        response_model=UserResponse,
+    )
+    async def update_user(user_id: str, data: UserUpdate):
+        return await auth_client.update_user(data.with_audit(updated_by="system"))
+
+    @app.delete(
+        "/api/v1/users/bulk",
+        response_model=list[UserResponse],
+    )
+    async def delete_user_bulk(user_ids: list[str]):
+        return await auth_client.delete_user_bulk(user_ids, deleted_by="system")
+
+    @app.delete(
+        "/api/v1/users/{user_id}",
+        response_model=UserResponse,
+    )
+    async def delete_user(user_id: str):
         return await auth_client.delete_user(user_id, deleted_by="system")

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

@@ -2,7 +2,7 @@ import os
 from typing import Any
 
 from fastapi.responses import HTMLResponse
-from my_app_name.common.view import render_page, render_str
+from my_app_name.common.util.view import render_page, render_str
 from my_app_name.config import (
     APP_GATEWAY_CSS_PATH_LIST,
     APP_GATEWAY_FAVICON_PATH,

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/requirements.txt

@@ -3,4 +3,4 @@ alembic~=1.14.0
 sqlmodel~=0.0.22
 ulid-py~=1.1.0
 passlib~=1.7.4
-Jinja2==3.1.4
+Jinja2==3.1.5

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/schema/permission.py

@@ -1,6 +1,7 @@
 import datetime
 
 import ulid
+from pydantic import BaseModel
 from sqlmodel import Field, SQLModel
 
 
@@ -11,6 +12,9 @@ class PermissionBase(SQLModel):
 class PermissionCreate(PermissionBase):
     description: str
 
+    def with_audit(self, created_by: str) -> "PermissionCreateWithAudit":
+        return PermissionCreateWithAudit(**self.model_dump(), created_by=created_by)
+
 
 class PermissionCreateWithAudit(PermissionCreate):
     created_by: str
@@ -20,6 +24,9 @@ class PermissionUpdate(SQLModel):
     name: str | None = None
     description: str | None = None
 
+    def with_audit(self, updated_by: str) -> "PermissionUpdateWithAudit":
+        return PermissionUpdateWithAudit(**self.model_dump(), updated_by=updated_by)
+
 
 class PermissionUpdateWithAudit(PermissionUpdate):
     updated_by: str
@@ -29,11 +36,16 @@ class PermissionResponse(PermissionBase):
     id: str
 
 
+class MultiplePermissionResponse(BaseModel):
+    data: list[PermissionResponse]
+    count: int
+
+
 class Permission(SQLModel, table=True):
     id: str = Field(default_factory=lambda: ulid.new().str, primary_key=True)
-    created_at: datetime.datetime | None
-    created_by: str | None
-    updated_at: datetime.datetime | None
-    updated_by: str | None
-    name: str
+    created_at: datetime.datetime | None = Field(index=True)
+    created_by: str | None = Field(index=True)
+    updated_at: datetime.datetime | None = Field(index=True)
+    updated_by: str | None = Field(index=True)
+    name: str = Field(index=True)
     description: str

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/schema/role.py

@@ -1,6 +1,8 @@
 import datetime
 
 import ulid
+from my_app_name.schema.permission import Permission
+from pydantic import BaseModel
 from sqlmodel import Field, SQLModel
 
 
@@ -11,15 +13,45 @@ class RoleBase(SQLModel):
 class RoleCreate(RoleBase):
     description: str
 
+    def with_audit(self, created_by: str) -> "RoleCreateWithAudit":
+        return RoleCreateWithAudit(**self.model_dump(), created_by=created_by)
+
 
 class RoleCreateWithAudit(RoleCreate):
     created_by: str
 
 
+class RoleCreateWithPermissions(RoleCreate):
+    permissions: list[str] | None = None
+
+    def with_audit(self, created_by: str) -> "RoleCreateWithPermissionsAndAudit":
+        return RoleCreateWithPermissionsAndAudit(
+            **self.model_dump(), created_by=created_by
+        )
+
+
+class RoleCreateWithPermissionsAndAudit(RoleCreateWithPermissions):
+    created_by: str
+
+    def get_role_create_with_audit(self) -> RoleCreateWithAudit:
+        data = {
+            key: val for key, val in self.model_dump().items() if key != "permissions"
+        }
+        return RoleCreateWithAudit(**data)
+
+    def get_permission_names(self) -> list[str]:
+        if self.permissions is None:
+            return []
+        return self.permissions
+
+
 class RoleUpdate(SQLModel):
     name: str | None = None
     description: str | None = None
 
+    def with_audit(self, updated_by: str) -> "RoleUpdateWithAudit":
+        return RoleUpdateWithAudit(**self.model_dump(), updated_by=updated_by)
+
 
 class RoleUpdateWithAudit(RoleUpdate):
     updated_by: str
@@ -27,13 +59,27 @@ class RoleUpdateWithAudit(RoleUpdate):
 
 class RoleResponse(RoleBase):
     id: str
+    permissions: list[Permission]
+
+
+class MultipleRoleResponse(BaseModel):
+    data: list[RoleResponse]
+    count: int
 
 
 class Role(SQLModel, table=True):
     id: str = Field(default_factory=lambda: ulid.new().str, primary_key=True)
+    created_at: datetime.datetime | None = Field(index=True)
+    created_by: str | None = Field(index=True)
+    updated_at: datetime.datetime | None = Field(index=True)
+    updated_by: str | None = Field(index=True)
+    name: str = Field(index=True)
+    description: str
+
+
+class RolePermission(SQLModel, table=True):
+    id: str = Field(default_factory=lambda: ulid.new().str, primary_key=True)
+    role_id: str = Field(index=True)
+    permission_id: str = Field(index=True)
     created_at: datetime.datetime | None
     created_by: str | None
-    updated_at: datetime.datetime | None
-    updated_by: str | None
-    name: str
-    description: str

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/schema/session.py

@@ -0,0 +1,52 @@
+import datetime
+
+import ulid
+from pydantic import BaseModel
+from sqlmodel import Field, SQLModel
+
+
+class SessionBase(SQLModel):
+    user_id: str
+    device: str
+    os: str
+    browser: str
+    expired_at: datetime.datetime | None
+
+
+class SessionCreate(SessionBase):
+
+    def with_audit(self, created_by: str) -> "SessionCreateWithAudit":
+        return SessionCreateWithAudit(**self.model_dump(), created_by=created_by)
+
+
+class SessionCreateWithAudit(SessionCreate):
+    created_by: str
+
+
+class SessionUpdate(SessionBase):
+
+    def with_audit(self, updated_by: str) -> "SessionUpdateWithAudit":
+        return SessionUpdateWithAudit(**self.model_dump(), updated_by=updated_by)
+
+
+class SessionUpdateWithAudit(SessionUpdate):
+    updated_by: str
+
+
+class SessionResponse(SessionBase):
+    id: str
+    created_at: datetime.datetime = Field(index=True)
+    updated_at: datetime.datetime | None = Field(index=True)
+
+
+class MultipleSessionResponse(BaseModel):
+    data: list[SessionResponse]
+    count: int
+
+
+class Session(SQLModel, table=True):
+    id: str = Field(default_factory=lambda: ulid.new().str, primary_key=True)
+    user_id: str = Field(index=True)
+    device: str
+    os: str
+    browser: str

zrb/builtin/project/add/fastapp/fastapp_template/my_app_name/schema/user.py

@@ -1,6 +1,9 @@
 import datetime
 
 import ulid
+from my_app_name.schema.permission import Permission
+from my_app_name.schema.role import Role
+from pydantic import BaseModel
 from sqlmodel import Field, SQLModel
 
 
@@ -10,6 +13,10 @@ class UserBase(SQLModel):
 
 class UserCreate(UserBase):
     password: str
+    roles: list[str] | None = None
+
+    def with_audit(self, created_by: str) -> "UserCreateWithAudit":
+        return UserCreateWithAudit(**self.model_dump(), created_by=created_by)
 
 
 class UserCreateWithAudit(UserCreate):
@@ -20,6 +27,9 @@ class UserUpdate(SQLModel):
     username: str | None = None
     password: str | None = None
 
+    def with_audit(self, updated_by: str) -> "UserUpdateWithAudit":
+        return UserUpdateWithAudit(**self.model_dump(), updated_by=updated_by)
+
 
 class UserUpdateWithAudit(UserUpdate):
     updated_by: str
@@ -27,13 +37,28 @@ class UserUpdateWithAudit(UserUpdate):
 
 class UserResponse(UserBase):
     id: str
+    roles: list[Role]
+    permissions: list[Permission]
+
+
+class MultipleUserResponse(BaseModel):
+    data: list[UserResponse]
+    count: int
 
 
 class User(SQLModel, table=True):
     id: str = Field(default_factory=lambda: ulid.new().str, primary_key=True)
-    created_at: datetime.datetime
-    created_by: str
-    updated_at: datetime.datetime
-    updated_by: str
-    username: str
+    created_at: datetime.datetime = Field(index=True)
+    created_by: str = Field(index=True)
+    updated_at: datetime.datetime | None = Field(index=True)
+    updated_by: str | None = Field(index=True)
+    username: str = Field(index=True)
     password: str
+
+
+class UserRole(SQLModel, table=True):
+    id: str = Field(default_factory=lambda: ulid.new().str, primary_key=True)
+    user_id: str = Field(index=True)
+    role_id: str = Field(index=True)
+    created_at: datetime.datetime | None
+    created_by: str | None