zrb 0.6.0__py3-none-any.whl → 0.6.1__py3-none-any.whl

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/entity/user/api.py

@@ -1,17 +1,16 @@
-from typing import Annotated, List, Mapping
-from fastapi import FastAPI, Depends
-from fastapi.security import OAuth2PasswordRequestForm
 from logging import Logger
+from typing import Annotated, List, Mapping
+
+from core.error import HTTPAPIException
 from core.messagebus import Publisher
 from core.rpc import Caller
-from core.error import HTTPAPIException
+from fastapi import Depends, FastAPI
+from fastapi.security import OAuth2PasswordRequestForm
+from module.auth.component import access_token_scheme, bearer_token_scheme
 from module.auth.core import Authorizer
-from module.auth.schema.user import (
-    User, UserData, UserResult, UserLogin
-)
+from module.auth.schema.request import IsAuthorizedRequest, RefreshTokenRequest
 from module.auth.schema.token import AccessTokenData, TokenResponse
-from module.auth.schema.request import RefreshTokenRequest, IsAuthorizedRequest
-from module.auth.component import access_token_scheme, bearer_token_scheme
+from module.auth.schema.user import User, UserData, UserLogin, UserResult
 
 
 def register_auth_api(
@@ -19,59 +18,55 @@ def register_auth_api(
     app: FastAPI,
     authorizer: Authorizer,
     rpc_caller: Caller,
-    publisher: Publisher
+    publisher: Publisher,
 ):
     logger.info('🥪 Register Login API for "auth.user"')
 
-    @app.post('/api/v1/auth/login-oauth', response_model=TokenResponse)
+    @app.post("/api/v1/auth/login-oauth", response_model=TokenResponse)
     async def login_oauth(
         form_data: Annotated[OAuth2PasswordRequestForm, Depends()]
     ) -> TokenResponse:
-        data = UserLogin(
-            identity=form_data.username,
-            password=form_data.password
-        )
+        data = UserLogin(identity=form_data.username, password=form_data.password)
         return await _create_token(data=data)
 
-    @app.post('/api/v1/auth/login', response_model=TokenResponse)
+    @app.post("/api/v1/auth/login", response_model=TokenResponse)
     async def login(data: UserLogin) -> TokenResponse:
         return await _create_token(data=data)
 
     async def _create_token(data: UserLogin) -> TokenResponse:
         try:
             token_response_dict = await rpc_caller.call(
-                'auth_create_token', login_data=data.dict()
+                "auth_create_token", login_data=data.model_dump()
             )
             return TokenResponse(**token_response_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
-    @app.post('/api/v1/auth/refresh-token', response_model=TokenResponse)
+    @app.post("/api/v1/auth/refresh-token", response_model=TokenResponse)
     async def refresh_token(
-        data: RefreshTokenRequest,
-        refresh_token: str = Depends(bearer_token_scheme)
+        data: RefreshTokenRequest, refresh_token: str = Depends(bearer_token_scheme)
     ) -> TokenResponse:
         try:
             token_response_dict = await rpc_caller.call(
-                'auth_refresh_token',
+                "auth_refresh_token",
                 refresh_token=refresh_token,
-                access_token=data.access_token
+                access_token=data.access_token,
             )
             return TokenResponse(**token_response_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
-    @app.post('/api/v1/auth/is-authorized', response_model=Mapping[str, bool])
+    @app.post("/api/v1/auth/is-authorized", response_model=Mapping[str, bool])
     async def is_authorized(
         data: IsAuthorizedRequest,
-        user_token_data: AccessTokenData = Depends(access_token_scheme)
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
     ) -> Mapping[str, str]:
         try:
             user_id = user_token_data.user_id
             return await rpc_caller.call(
-                'auth_is_user_authorized',
+                "auth_is_user_authorized",
                 id=user_id,
-                permission_name=data.permission_names
+                permission_name=data.permission_names,
             )
         except Exception as e:
             raise HTTPAPIException(error=e)
@@ -82,109 +77,102 @@ def register_api(
     app: FastAPI,
     authorizer: Authorizer,
     rpc_caller: Caller,
-    publisher: Publisher
+    publisher: Publisher,
 ):
     logger.info('🥪 Register API for "auth.user"')
 
-    @app.get(
-        '/api/v1/auth/users', response_model=UserResult
-    )
+    @app.get("/api/v1/auth/users", response_model=UserResult)
     async def get_users(
-        keyword: str = '', limit: int = 100, offset: int = 0,
-        user_token_data: AccessTokenData = Depends(access_token_scheme)
+        keyword: str = "",
+        limit: int = 100,
+        offset: int = 0,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'auth:user:get'
+            user_token_data.user_id, "auth:user:get"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'auth_get_user',
+                "auth_get_user",
                 keyword=keyword,
                 criterion={},
                 limit=limit,
                 offset=offset,
-                user_token_data=user_token_data.dict()
+                user_token_data=user_token_data.model_dump(),
             )
             return UserResult(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
-    @app.get(
-        '/api/v1/auth/users/{id}', response_model=User
-    )
+    @app.get("/api/v1/auth/users/{id}", response_model=User)
     async def get_user_by_id(
-        id: str,
-        user_token_data: AccessTokenData = Depends(access_token_scheme)
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'auth:user:get_by_id'
+            user_token_data.user_id, "auth:user:get_by_id"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'auth_get_user_by_id',
-                id=id, user_token_data=user_token_data.dict()
+                "auth_get_user_by_id",
+                id=id,
+                user_token_data=user_token_data.model_dump(),
             )
             return User(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
-    @app.post(
-        '/api/v1/auth/users', response_model=User
-    )
+    @app.post("/api/v1/auth/users", response_model=User)
     async def insert_user(
-        data: UserData,
-        user_token_data: AccessTokenData = Depends(access_token_scheme)
+        data: UserData, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'auth:user:insert'
+            user_token_data.user_id, "auth:user:insert"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'auth_insert_user',
-                data=data.dict(), user_token_data=user_token_data.dict()
+                "auth_insert_user",
+                data=data.model_dump(),
+                user_token_data=user_token_data.model_dump(),
             )
             return User(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
-    @app.put(
-        '/api/v1/auth/users/{id}', response_model=User
-    )
+    @app.put("/api/v1/auth/users/{id}", response_model=User)
     async def update_user(
-        id: str, data: UserData,
-        user_token_data: AccessTokenData = Depends(access_token_scheme)
+        id: str,
+        data: UserData,
+        user_token_data: AccessTokenData = Depends(access_token_scheme),
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'auth:user:update'
+            user_token_data.user_id, "auth:user:update"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'auth_update_user',
-                id=id, data=data.dict(), user_token_data=user_token_data.dict()
+                "auth_update_user",
+                id=id,
+                data=data.model_dump(),
+                user_token_data=user_token_data.model_dump(),
             )
             return User(**result_dict)
         except Exception as e:
             raise HTTPAPIException(error=e)
 
-    @app.delete(
-        '/api/v1/auth/users/{id}', response_model=User
-    )
+    @app.delete("/api/v1/auth/users/{id}", response_model=User)
     async def delete_user(
-        id: str,
-        user_token_data: AccessTokenData = Depends(access_token_scheme)
+        id: str, user_token_data: AccessTokenData = Depends(access_token_scheme)
     ):
         if not await authorizer.is_having_permission(
-            user_token_data.user_id, 'auth:user:delete'
+            user_token_data.user_id, "auth:user:delete"
         ):
-            raise HTTPAPIException(403, 'Unauthorized')
+            raise HTTPAPIException(403, "Unauthorized")
         try:
             result_dict = await rpc_caller.call(
-                'auth_delete_user',
-                id=id, user_token_data=user_token_data.dict()
+                "auth_delete_user", id=id, user_token_data=user_token_data.model_dump()
             )
             return User(**result_dict)
         except Exception as e:

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/entity/user/model.py

@@ -1,22 +1,17 @@
-from typing import Optional, List, Mapping
+from typing import List, Mapping, Optional
+
 from core.messagebus.messagebus import Publisher
-from module.log.core.historical_repo_model import HistoricalRepoModel
-from module.auth.schema.user import (
-    User, UserData, UserResult, UserLogin
-)
-from module.auth.entity.user.repo import UserRepo
-from module.auth.schema.token import (
-    AccessTokenData, RefreshTokenData, TokenResponse
-)
 from module.auth.core import AccessTokenUtil, RefreshTokenUtil
 from module.auth.entity.permission.model import PermissionModel
+from module.auth.entity.user.repo import UserRepo
+from module.auth.schema.token import AccessTokenData, RefreshTokenData, TokenResponse
+from module.auth.schema.user import User, UserData, UserLogin, UserResult
+from module.log.core.historical_repo_model import HistoricalRepoModel
 
 
-class UserModel(
-    HistoricalRepoModel[User, UserData, UserResult]
-):
+class UserModel(HistoricalRepoModel[User, UserData, UserResult]):
     schema_result_cls = UserResult
-    log_entity_name = 'user'
+    log_entity_name = "user"
 
     def __init__(
         self,
@@ -24,12 +19,12 @@ class UserModel(
         publisher: Publisher,
         permission_model: PermissionModel,
         access_token_util: AccessTokenUtil,
-        access_token_expire_seconds: int,
+        access_token_expire_seconds: int | float,
         refresh_token_util: RefreshTokenUtil,
-        refresh_token_expire_seconds: int,
+        refresh_token_expire_seconds: int | float,
         guest_user: User,
         admin_user: Optional[User] = None,
-        admin_user_password: str = ''
+        admin_user_password: str = "",
     ):
         super().__init__(repo, publisher)
         self.permission_model = permission_model
@@ -42,48 +37,29 @@ class UserModel(
         self.admin_user_pasword = admin_user_password
 
     async def insert(self, data: UserData) -> User:
-        if (
-            self.admin_user is not None and
-            data.username == self.admin_user.username
-        ):
-            raise ValueError(
-                f'Invalid username: {data.username} is used by admin'
-            )
+        if self.admin_user is not None and data.username == self.admin_user.username:
+            raise ValueError(f"Invalid username: {data.username} is used by admin")
         if data.username == self.guest_user.username:
-            raise ValueError(
-                f'Invalid username: {data.username} is used by guest'
-            )
+            raise ValueError(f"Invalid username: {data.username} is used by guest")
         return await super().insert(data)
 
     async def update(self, id: str, data: UserData) -> User:
         if self.admin_user is not None:
             if self.is_admin(id):
-                raise ValueError(
-                    'Forbidden: editting admin user is not permitted'
-                )
+                raise ValueError("Forbidden: editting admin user is not permitted")
             if data.username == self.admin_user.username:
-                raise ValueError(
-                    f'Invalid username: {data.username} is used by admin'
-                )
+                raise ValueError(f"Invalid username: {data.username} is used by admin")
         if self.is_guest(id):
-            raise ValueError(
-                'Forbidden: editting guest user is not permitted'
-            )
+            raise ValueError("Forbidden: editting guest user is not permitted")
         if data.username == self.guest_user.username:
-            raise ValueError(
-                f'Invalid username: {data.username} is used by guest'
-            )
+            raise ValueError(f"Invalid username: {data.username} is used by guest")
         return await super().update(id, data)
 
     async def delete(self, id: str) -> User:
         if self.admin_user is not None and self.is_admin(id):
-            raise ValueError(
-                'Forbidden: deleting admin user is not permitted'
-            )
+            raise ValueError("Forbidden: deleting admin user is not permitted")
         if self.is_guest(id):
-            raise ValueError(
-                'Forbidden: deleting guest user is not permitted'
-            )
+            raise ValueError("Forbidden: deleting guest user is not permitted")
         return await super().delete(id)
 
     async def get_by_id(self, id: str) -> User:
@@ -98,9 +74,7 @@ class UserModel(
     ) -> Mapping[str, bool]:
         user = await self.get_by_id(id)
         if self.is_admin(user.id):
-            return {
-                permission_name: True for permission_name in permission_names
-            }
+            return {permission_name: True for permission_name in permission_names}
         user_permission_names = self._get_permission_names(user)
         return {
             permission_name: permission_name in user_permission_names
@@ -108,9 +82,7 @@ class UserModel(
         }
 
     def _get_permission_names(self, user: User) -> List[str]:
-        permission_names = [
-            permission.name for permission in user.permissions
-        ]
+        permission_names = [permission.name for permission in user.permissions]
         for group in user.groups:
             additional_permission_names = [
                 permission.name
@@ -133,7 +105,7 @@ class UserModel(
         return TokenResponse(
             access_token=self._get_access_token(user),
             refresh_token=self._get_refresh_token(user),
-            token_type='bearer'
+            token_type="bearer",
         )
 
     async def refresh_auth_token(
@@ -144,39 +116,38 @@ class UserModel(
         )
         refresh_token_data = self.refresh_token_util.decode(refresh_token)
         if access_token_data.user_id != refresh_token_data.user_id:
-            raise ValueError('Unmatch refresh and access token')
+            raise ValueError("Unmatch refresh and access token")
         user = await self.get_by_id(refresh_token_data.user_id)
         return TokenResponse(
             access_token=self._get_access_token(user),
             refresh_token=self._get_refresh_token(user),
-            token_type='bearer'
+            token_type="bearer",
         )
 
     def _get_access_token(self, user: User) -> str:
         access_token_data = AccessTokenData(
             user_id=user.id,
             username=user.username,
-            expire_seconds=self.access_token_expire_seconds
+            expire_seconds=self.access_token_expire_seconds,
         )
         return self.access_token_util.encode(access_token_data)
 
     def _get_refresh_token(self, user: User) -> str:
         refresh_token_data = RefreshTokenData(
-            user_id=user.id,
-            expire_seconds=self.refresh_token_expire_seconds
+            user_id=user.id, expire_seconds=self.refresh_token_expire_seconds
         )
         return self.refresh_token_util.encode(refresh_token_data)
 
     async def _get_user_by_user_login(self, user_login: UserLogin) -> User:
-        if user_login.identity == '':
-            raise ValueError('Invalid identity: Identity is empty')
+        if user_login.identity == "":
+            raise ValueError("Invalid identity: Identity is empty")
         if (
             self.admin_user is not None
             and user_login.password == self.admin_user_pasword
             and (
-                user_login.identity == self.admin_user.username or
-                user_login.identity == self.admin_user.email or
-                user_login.identity == self.admin_user.phone
+                user_login.identity == self.admin_user.username
+                or user_login.identity == self.admin_user.email
+                or user_login.identity == self.admin_user.phone
             )
         ):
             return self.admin_user

zrb/builtin/generator/fastapp/template/src/kebab-zrb-app-name/src/module/auth/entity/user/repo.py

@@ -1,34 +1,32 @@
-from typing import Any, List, Mapping
+import logging
 from abc import ABC, abstractmethod
-from sqlalchemy import Column, String, or_
-from sqlalchemy.orm import Session, relationship
-from sqlalchemy.engine import Engine
-from core.repo import Repo, DBEntityMixin, DBRepo
-from module.auth.schema.user import User, UserData, UserLogin
-from module.auth.core import PasswordHasher
+from typing import Any, List, Mapping
+
+from core.repo import DBEntityMixin, DBRepo, Repo
 from module.auth.component import Base
-from module.auth.entity.table import user_group, user_permission
-from module.auth.entity.permission.repo import DBEntityPermission
+from module.auth.core import PasswordHasher
 from module.auth.entity.group.repo import DBEntityGroup
-
-import logging
+from module.auth.entity.permission.repo import DBEntityPermission
+from module.auth.entity.table import user_group, user_permission
+from module.auth.schema.user import User, UserData, UserLogin
+from sqlalchemy import Column, String, or_
+from sqlalchemy.engine import Engine
+from sqlalchemy.orm import Session, relationship
 
 
 class DBEntityUser(Base, DBEntityMixin):
+    class Config:
+        orm_mode = True
+        from_attributes = True
+
     __tablename__ = "users"
     username = Column(String)
     phone = Column(String)
     email = Column(String)
     description = Column(String)
     hashed_password = Column(String)
-    permissions = relationship(
-        "DBEntityPermission",
-        secondary=user_permission
-    )
-    groups = relationship(
-        "DBEntityGroup",
-        secondary=user_group
-    )
+    permissions = relationship("DBEntityPermission", secondary=user_permission)
+    groups = relationship("DBEntityGroup", secondary=user_group)
 
 
 class UserRepo(Repo[User, UserData], ABC):
@@ -37,17 +35,12 @@ class UserRepo(Repo[User, UserData], ABC):
         pass
 
 
-class UserDBRepo(
-    DBRepo[User, UserData], UserRepo
-):
+class UserDBRepo(DBRepo[User, UserData], UserRepo):
     schema_cls = User
     db_entity_cls = DBEntityUser
 
     def __init__(
-        self,
-        logger: logging.Logger,
-        engine: Engine,
-        password_hasher: PasswordHasher
+        self, logger: logging.Logger, engine: Engine, password_hasher: PasswordHasher
     ):
         super().__init__(logger, engine)
         self.password_hasher = password_hasher
@@ -59,7 +52,7 @@ class UserDBRepo(
             search_filter = or_(
                 DBEntityUser.username == user_login.identity,
                 DBEntityUser.phone == user_login.identity,
-                DBEntityUser.email == user_login.identity
+                DBEntityUser.email == user_login.identity,
             )
             db_users = [
                 db_user
@@ -69,7 +62,7 @@ class UserDBRepo(
                 )
             ]
             if len(db_users) == 0:
-                raise ValueError('Not found: Cannot find any user')
+                raise ValueError("Not found: Cannot find any user")
             return self._db_entity_to_schema(db, db_users[0])
         finally:
             db.close()
@@ -79,16 +72,20 @@ class UserDBRepo(
     ) -> Mapping[str, Any]:
         db_entity_map = super()._schema_data_to_db_entity_map(db, user_data)
         # Transform permissions
-        db_entity_map['permissions'] = db.query(DBEntityPermission).filter(
-            DBEntityPermission.id.in_(user_data.permissions)
-        ).all()
+        db_entity_map["permissions"] = (
+            db.query(DBEntityPermission)
+            .filter(DBEntityPermission.id.in_(user_data.permissions))
+            .all()
+        )
         # Transform groups
-        db_entity_map['groups'] = db.query(DBEntityGroup).filter(
-            DBEntityGroup.id.in_(user_data.groups)
-        ).all()
+        db_entity_map["groups"] = (
+            db.query(DBEntityGroup).filter(DBEntityGroup.id.in_(user_data.groups)).all()
+        )
         # add hashed password if necessary
-        if user_data.password != '':
-            db_entity_map['hashed_password'] = self.password_hasher.hash_password( # noqa
+        if user_data.password != "":
+            db_entity_map[
+                "hashed_password"
+            ] = self.password_hasher.hash_password(  # noqa
                 user_data.password
             )
         return db_entity_map