shaapi 0.1.0__py3-none-any.whl

shaapi/template/backend/app/admin/service/casbin_service.py

@@ -0,0 +1,135 @@
+from uuid import UUID
+
+from sqlalchemy import Select
+
+from backend.crud.crud_casbin import casbin_dao
+from backend.app.admin.schema.casbin_rule import (
+    CreatePolicyParam,
+    CreateUserRoleParam,
+    DeleteAllPoliciesParam,
+    DeletePolicyParam,
+    DeleteUserRoleParam,
+    UpdatePolicyParam,
+)
+from backend.common.exception import errors
+from backend.common.security.rbac import rbac
+from backend.database.db_postgres import async_db_session
+
+
+class CasbinService:
+    @staticmethod
+    async def get_casbin_list(*, ptype: str, sub: str) -> Select:
+        return await casbin_dao.get_list(ptype, sub)
+
+    @staticmethod
+    async def get_policy_list(*, role: int | None = None) -> list:
+        enforcer = await rbac.enforcer()
+        if role is not None:
+            data = enforcer.get_filtered_named_policy('p', 0, str(role))
+        else:
+            data = enforcer.get_policy()
+        return data
+
+    @staticmethod
+    async def create_policy(*, p: CreatePolicyParam) -> bool:
+        enforcer = await rbac.enforcer()
+        data = await enforcer.add_policy(p.sub, p.path, p.method)
+        if not data:
+            raise errors.ForbiddenError(msg='Permission already exists')
+        return data
+
+    @staticmethod
+    async def create_policies(*, ps: list[CreatePolicyParam]) -> bool:
+        enforcer = await rbac.enforcer()
+        data = await enforcer.add_policies([list(p.model_dump().values()) for p in ps])
+        if not data:
+            raise errors.ForbiddenError(msg='Permission already exists')
+        return data
+
+    @staticmethod
+    async def update_policy(*, old: UpdatePolicyParam, new: UpdatePolicyParam) -> bool:
+        enforcer = await rbac.enforcer()
+        _p = enforcer.has_policy(old.sub, old.path, old.method)
+        if not _p:
+            raise errors.NotFoundError(msg='Permission does not exist')
+        data = await enforcer.update_policy([old.sub, old.path, old.method], [new.sub, new.path, new.method])
+        return data
+
+    @staticmethod
+    async def update_policies(*, old: list[UpdatePolicyParam], new: list[UpdatePolicyParam]) -> bool:
+        enforcer = await rbac.enforcer()
+        data = await enforcer.update_policies(
+            [list(o.model_dump().values()) for o in old], [list(n.model_dump().values()) for n in new]
+        )
+        return data
+
+    @staticmethod
+    async def delete_policy(*, p: DeletePolicyParam) -> bool:
+        enforcer = await rbac.enforcer()
+        _p = enforcer.has_policy(p.sub, p.path, p.method)
+        if not _p:
+            raise errors.NotFoundError(msg='Permission does not exist')
+        data = await enforcer.remove_policy(p.sub, p.path, p.method)
+        return data
+
+    @staticmethod
+    async def delete_policies(*, ps: list[DeletePolicyParam]) -> bool:
+        enforcer = await rbac.enforcer()
+        data = await enforcer.remove_policies([list(p.model_dump().values()) for p in ps])
+        if not data:
+            raise errors.NotFoundError(msg='Permission does not exist')
+        return data
+
+    @staticmethod
+    async def delete_all_policies(*, sub: DeleteAllPoliciesParam) -> int:
+        async with async_db_session.begin() as db:
+            count = await casbin_dao.delete_policies_by_sub(db, sub)
+        return count
+
+    @staticmethod
+    async def get_group_list() -> list:
+        enforcer = await rbac.enforcer()
+        data = enforcer.get_grouping_policy()
+        return data
+
+    @staticmethod
+    async def create_group(*, g: CreateUserRoleParam) -> bool:
+        enforcer = await rbac.enforcer()
+        data = await enforcer.add_grouping_policy(g.uuid, g.role)
+        if not data:
+            raise errors.ForbiddenError(msg='Permission already exists')
+        return data
+
+    @staticmethod
+    async def create_groups(*, gs: list[CreateUserRoleParam]) -> bool:
+        enforcer = await rbac.enforcer()
+        data = await enforcer.add_grouping_policies([list(g.model_dump().values()) for g in gs])
+        if not data:
+            raise errors.ForbiddenError(msg='Permission already exists')
+        return data
+
+    @staticmethod
+    async def delete_group(*, g: DeleteUserRoleParam) -> bool:
+        enforcer = await rbac.enforcer()
+        _g = enforcer.has_grouping_policy(g.uuid, g.role)
+        if not _g:
+            raise errors.NotFoundError(msg='Permission does not exist')
+        data = await enforcer.remove_grouping_policy(g.uuid, g.role)
+        return data
+
+    @staticmethod
+    async def delete_groups(*, gs: list[DeleteUserRoleParam]) -> bool:
+        enforcer = await rbac.enforcer()
+        data = await enforcer.remove_grouping_policies([list(g.model_dump().values()) for g in gs])
+        if not data:
+            raise errors.NotFoundError(msg='Permission does not exist')
+        return data
+
+    @staticmethod
+    async def delete_all_groups(*, uuid: UUID) -> int:
+        async with async_db_session.begin() as db:
+            count = await casbin_dao.delete_groups_by_uuid(db, uuid)
+        return count
+
+
+casbin_service = CasbinService()

shaapi/template/backend/app/admin/service/login_log_service.py

@@ -0,0 +1,62 @@
+from datetime import datetime
+
+from fastapi import Request
+from sqlalchemy import Select
+from sqlalchemy.ext.asyncio import AsyncSession
+
+from backend.crud.crud_login_log import login_log_dao
+from backend.app.admin.schema.login_log import CreateLoginLogParam
+from backend.common.log import log
+from backend.database.db_postgres import async_db_session
+
+
+class LoginLogService:
+    @staticmethod
+    async def get_select(*, username: str, status: int, ip: str) -> Select:
+        return await login_log_dao.get_list(username=username, status=status, ip=ip)
+
+    @staticmethod
+    async def create(
+        *,
+        db: AsyncSession,
+        request: Request,
+        user_x_id: str,
+        email: str,
+        login_time: datetime,
+        status: int,
+        msg: str,
+    ) -> None:
+        try:
+            obj_in = CreateLoginLogParam(
+                user_x_id=user_x_id,
+                email=email,
+                status=status,
+                ip=request.state.ip,
+                country=request.state.country,
+                region=request.state.region,
+                city=request.state.city,
+                user_agent=request.state.user_agent,
+                browser=request.state.browser,
+                os=request.state.os,
+                device=request.state.device,
+                msg=msg,
+                login_time=login_time,
+            )
+            await login_log_dao.create(db, obj_in)
+        except Exception as e:
+            log.error(f'Login log creation failure: {e}')
+
+    @staticmethod
+    async def delete(*, pk: list[int]) -> int:
+        async with async_db_session.begin() as db:
+            count = await login_log_dao.delete(db, pk)
+            return count
+
+    @staticmethod
+    async def delete_all() -> int:
+        async with async_db_session.begin() as db:
+            count = await login_log_dao.delete_all(db)
+            return count
+
+
+login_log_service = LoginLogService()

shaapi/template/backend/app/admin/service/opera_log_service.py

@@ -0,0 +1,31 @@
+from sqlalchemy import Select
+
+from backend.crud.crud_opera_log import opera_log_dao
+from backend.app.admin.schema.opera_log import CreateOperaLogParam
+from backend.database.db_postgres import async_db_session
+
+
+class OperaLogService:
+    @staticmethod
+    async def get_select(*, username: str | None = None, status: int | None = None, ip: str | None = None) -> Select:
+        return await opera_log_dao.get_list(username=username, status=status, ip=ip)
+
+    @staticmethod
+    async def create(*, obj_in: CreateOperaLogParam):
+        async with async_db_session.begin() as db:
+            await opera_log_dao.create(db, obj_in)
+
+    @staticmethod
+    async def delete(*, pk: list[int]) -> int:
+        async with async_db_session.begin() as db:
+            count = await opera_log_dao.delete(db, pk)
+            return count
+
+    @staticmethod
+    async def delete_all() -> int:
+        async with async_db_session.begin() as db:
+            count = await opera_log_dao.delete_all(db)
+            return count
+
+
+opera_log_service = OperaLogService()

shaapi/template/backend/app/admin/service/role_service.py

@@ -0,0 +1,79 @@
+from typing import Sequence
+
+from fastapi import Request
+from sqlalchemy import Select
+
+from backend.crud.crud_role import role_dao
+from backend.models import Role
+from backend.app.admin.schema.role import CreateRoleParam, UpdateRoleMenuParam, UpdateRoleParam
+from backend.common.exception import errors
+from backend.core.conf import settings
+from backend.database.db_postgres import async_db_session
+from backend.database.db_redis import redis_client
+
+
+class RoleService:
+    
+    @staticmethod
+    async def get_by_id(role_id: int) -> Role | None:
+        """
+        Get role by id
+
+        :param db:
+        :param role_id:
+        :return:
+        """
+        async with async_db_session() as db:
+            return await role_dao.get(db, role_id)
+
+    @staticmethod
+    async def get_all() -> Sequence[Role]:
+        async with async_db_session() as db:
+            roles = await role_dao.get_all(db)
+            return roles
+
+    @staticmethod
+    async def get_user_roles(*, pk: int) -> Sequence[Role]:
+        async with async_db_session() as db:
+            roles = await role_dao.get_user_roles(db, user_id=pk)
+            return roles
+
+    @staticmethod
+    async def get_select(*, name: str = None, data_scope: int = None, status: int = None) -> Select:
+        return await role_dao.get_list(name=name, data_scope=data_scope, status=status)
+
+    @staticmethod
+    async def create(*, obj: CreateRoleParam) -> None:
+        async with async_db_session.begin() as db:
+            role = await role_dao.get_by_name(db, obj.name)
+            if role:
+                raise errors.ForbiddenError(msg='already exists')
+            await role_dao.create(db, obj)
+
+    @staticmethod
+    async def get_by_name(name: str) -> Role | None:
+        async with async_db_session() as db:
+            return await role_dao.get_by_name(db, name)
+        
+    @staticmethod
+    async def update(*, pk: int, obj: UpdateRoleParam) -> int:
+        async with async_db_session.begin() as db:
+            role = await role_dao.get(db, pk)
+            if not role:
+                raise errors.NotFoundError(msg='not found')
+            if role.name != obj.name:
+                role = await role_dao.get_by_name(db, obj.name)
+                if role:
+                    raise errors.ForbiddenError(msg='already exists')
+            count = await role_dao.update_roleinfo(db, pk, obj)
+            return count
+
+    
+    @staticmethod
+    async def delete(*, pk: list[int]) -> int:
+        async with async_db_session.begin() as db:
+            count = await role_dao.delete(db, pk)
+            return count
+
+
+role_service = RoleService()

shaapi/template/backend/app/admin/service/secure_token_service.py

@@ -0,0 +1,60 @@
+from datetime import datetime, timedelta
+from backend.common.enums import Secure_token_type
+from backend.common.exception import errors
+from backend.common.security.sec_token import generate_secret_token
+from backend.app.admin.schema.token import Secure_token
+from backend.database.db_redis import redis_client
+from backend.core.conf import settings
+
+
+
+
+class Secure_tokenService:
+    @staticmethod
+    async def gen_token(user_x_id: str, type: Secure_token_type, expire: int | None = None) -> str:
+        token = generate_secret_token()
+        expiration=(datetime.now() + timedelta(minutes=expire)) if expire is not None else (datetime.now() + timedelta(minutes=5))
+        password_reset_token = Secure_token(
+            token=token,
+            token_type=type,
+            user_x_id=user_x_id,
+            expiration=expiration,
+        )
+        
+        add = await redis_client.set(
+            f"{settings.USER_SECURE_TOKEN_REDIS_PREFIX}:{user_x_id}:{type.value}",
+            password_reset_token.model_dump_json(),
+            timedelta(minutes=expire) if expire is not None else None,
+        )
+        
+        if not add:
+            raise errors.ServerError(msg='Token generation failed')
+        return token
+    
+    @staticmethod
+    async def check_token(token: str, user_x_id: str, type: Secure_token_type) -> bool:
+        rst_token = await redis_client.get(f"{settings.USER_SECURE_TOKEN_REDIS_PREFIX}:{user_x_id}:{type.value}")
+        if not rst_token:
+            raise errors.TokenError(msg='Token has expired')
+        
+        validate_token = Secure_token.model_validate_json(rst_token)
+
+        if validate_token.used:
+            raise errors.TokenError(msg='Token has been used')
+        
+        if validate_token.expiration < datetime.now():
+            raise errors.TokenError(msg='Token has expired')
+        if validate_token.token_type != type.value:
+            raise errors.TokenError(msg='Token type is invalid')
+        if validate_token.token != token:
+            raise errors.TokenError(msg='Token user is invalid')
+        
+        validate_token.used = True
+        await redis_client.set(
+            f"{settings.USER_SECURE_TOKEN_REDIS_PREFIX}:{user_x_id}:{type.value}",
+            validate_token.model_dump_json(),
+        )
+        print("validate_token =====>", validate_token.used)
+        return True
+    
+secure_token_service = Secure_tokenService()

shaapi/template/backend/app/admin/service/user_service.py

@@ -0,0 +1,153 @@
+import random
+from typing import Union
+
+from fastapi import Request
+from pydantic import EmailStr
+from sqlalchemy import Select, Sequence
+
+from backend.app.admin.service.secure_token_service import secure_token_service
+from backend.common.enums import Secure_token_type
+from backend.crud.crud_user import user_dao
+from backend.models import User
+from backend.app.admin.schema.user import (
+    UpdatePasswordParam,
+    UserResetPassword,
+    UpdateUserParam
+)
+from backend.common.exception import errors
+from backend.common.security.jwt import get_hash_password, password_verify, superuser_verify
+from backend.core.conf import settings
+from backend.database.db_postgres import async_db_session
+from backend.database.db_redis import redis_client
+from backend.common.enums import Role as Role_enum
+
+
+
+class ClientService:
+    @staticmethod
+    async def pwd_update(*, request: Request, obj: UpdatePasswordParam) -> int:
+        async with async_db_session.begin() as db:
+            user = await user_dao.get(db, request.user.id)
+            if not password_verify(f'{obj.old_password}{user.salt}', user.password):
+                raise errors.ForbiddenError(msg='Original password is wrong')
+            
+            np1 = obj.new_password
+            np2 = obj.confirm_password
+
+            if np1 != np2:
+                raise errors.ForbiddenError(msg='Inconsistent password entry')
+
+            new_pwd = get_hash_password(f'{obj.new_password}{user.salt}')
+            count = await user_dao.reset_password(db, request.user.id, new_pwd)
+            key_prefix = [
+                f'{settings.TOKEN_REDIS_PREFIX}:{request.user.id}',
+                f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{request.user.id}',
+                f'{settings.JWT_USER_REDIS_PREFIX}:{request.user.id}',
+            ]
+            for key in key_prefix:
+                await redis_client.delete_prefix(key)
+            return count
+    
+    @staticmethod
+    async def pwd_reset(*, email: EmailStr, token: str, obj: UserResetPassword) -> int:
+        async with async_db_session.begin() as db:
+            user = await user_dao.get_by_email(db, email)
+            if not user:
+                raise errors.NotFoundError(msg='Invalid information')
+            np1 = obj.new_password
+            np2 = obj.confirm_password
+
+            if np1 != np2:
+                raise errors.ForbiddenError(msg='Inconsistent password entry')
+            check_token = await secure_token_service.check_token(token=token, user_x_id=user.x_id, type=Secure_token_type.RESET_PWD)
+            if not check_token:
+                raise errors.ForbiddenError(msg='Token is invalid')
+            
+            new_pwd = get_hash_password(f'{obj.new_password}{user.salt}')
+            count = await user_dao.reset_password(db, user.id, new_pwd)
+            key_prefix = [
+                f'{settings.TOKEN_REDIS_PREFIX}:{user.id}',
+                f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{user.id}',
+                f'{settings.JWT_USER_REDIS_PREFIX}:{user.id}',
+            ]
+            for key in key_prefix:
+                await redis_client.delete_prefix(key)
+            return count
+        
+    @staticmethod
+    async def get_userinfo(*, email: str) -> User:
+        async with async_db_session() as db:
+            user = await user_dao.get_with_relation(db, email=email)
+            if not user:
+                raise errors.NotFoundError(msg='The user does not exist')
+            return user
+    @staticmethod
+    async def get_by_email(*, email: EmailStr) -> User | None:
+        async with async_db_session() as db:
+            user = await user_dao.get_with_relation(db, email=email)
+            return user
+    @staticmethod
+    async def update_profile_image(*, request: Request, email: str, profile_image: dict) -> int:
+        async with async_db_session.begin() as db:
+            input_user = await user_dao.get_by_email(db, email)
+            if not input_user:
+                raise errors.NotFoundError(msg='The user does not exist')
+            count = await user_dao.update_profile_image(db, input_user.id, profile_image)
+            return count
+    
+    @staticmethod
+    async def update(*, id: int, obj: UpdateUserParam) -> int:
+        async with async_db_session.begin() as db:
+            input_user = await user_dao.get_with_relation(db, id=id, populates=[])
+            if not input_user:
+                raise errors.NotFoundError(msg='The user does not exist')
+
+            count = await user_dao.update_user_info(db, id, obj.model_dump(exclude_none=True, exclude_unset=True, exclude={}))
+            return count
+    @staticmethod
+    async def get_profile(*, id: int) -> User:
+        async with async_db_session() as db:
+            user = await user_dao.get_with_relation(db, id=id, populates=[])
+            if not user:
+                raise errors.NotFoundError(msg='The user does not exist')
+            return user
+
+    @staticmethod
+    async def get_select(
+        *, 
+        q: str | None = None, 
+        email: str | None = None, 
+        phone: str | None = None, 
+        status: bool | None = None, 
+        role: str | None = None 
+    ) -> Select:
+        async with async_db_session() as db:
+            return await user_dao.get_list(email=email, phone=phone, status=status)
+
+    @staticmethod
+    async def get_all() -> Sequence[User]:
+        async with async_db_session() as db:
+            users = await user_dao.get_all(db)
+            return users
+    @staticmethod
+    async def delete(*, email: str) -> int:
+        async with async_db_session.begin() as db:
+            input_user = await user_dao.get_by_email(db, email=email)
+            if not input_user:
+                raise errors.NotFoundError(msg='The user does not exist')
+            count = await user_dao.delete(db, input_user.id)
+            key_prefix = [
+                f'{settings.TOKEN_REDIS_PREFIX}:{input_user.id}',
+                f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{input_user.id}',
+            ]
+            for key in key_prefix:
+                await redis_client.delete_prefix(key)
+            return count
+
+    @staticmethod
+    async def get_by_x_id(x_id: str) -> User | None:
+        async with async_db_session() as db:
+            return await user_dao.get_by_stb_id(db, x_id)
+
+    
+user_service = ClientService()

shaapi/template/backend/app/api.py

@@ -0,0 +1,11 @@
+from fastapi import APIRouter
+from backend.app import Handlers
+from backend.core.conf import settings
+
+admin_router = APIRouter(prefix=f"{settings.FASTAPI_API_V1_PATH}")
+
+
+for handler in Handlers.iterator():
+    if getattr(handler, 'router', None):
+        if handler.__name__.split('.')[-4] == 'admin':
+            admin_router.include_router(handler.router)

shaapi/template/backend/common/cloud_storage/__init__.py

@@ -0,0 +1,11 @@
+from .cloud_storage import MinioStorage
+from backend.core.conf import settings
+
+
+
+mstorage = MinioStorage(
+    access_key=settings.MINIO_ACCESS_KEY,
+    secret_key=settings.MINIO_SECRET_KEY,
+    endpoint_url=settings.MINIO_ENDPOINT,
+    bucket_name=settings.MINIO_BUCKET_NAME,
+)