shaapi 0.1.0__py3-none-any.whl

shaapi/template/backend/alembic.ini

@@ -0,0 +1,117 @@
+# A generic, single database configuration.
+
+[alembic]
+# path to migration scripts
+# Use forward slashes (/) also on windows to provide an os agnostic path
+script_location = alembic
+
+# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
+# Uncomment the line below if you want the files to be prepended with date and time
+# see https://alembic.sqlalchemy.org/en/latest/tutorial.html#editing-the-ini-file
+# for all available tokens
+file_template = %%(year)d_%%(month).2d_%%(day).2d_%%(hour).2d%%(minute).2d-%%(rev)s_%%(slug)s
+
+# sys.path path, will be prepended to sys.path if present.
+# defaults to the current working directory.
+prepend_sys_path = .
+
+# timezone to use when rendering the date within the migration file
+# as well as the filename.
+# If specified, requires the python>=3.9 or backports.zoneinfo library.
+# Any required deps can installed by adding `alembic[tz]` to the pip requirements
+# string value is passed to ZoneInfo()
+# leave blank for localtime
+# timezone =
+
+# max length of characters to apply to the "slug" field
+# truncate_slug_length = 40
+
+# set to 'true' to run the environment during
+# the 'revision' command, regardless of autogenerate
+# revision_environment = false
+
+# set to 'true' to allow .pyc and .pyo files without
+# a source .py file to be detected as revisions in the
+# versions/ directory
+# sourceless = false
+
+# version location specification; This defaults
+# to alembic/versions.  When using multiple version
+# directories, initial revisions must be specified with --version-path.
+# The path separator used here should be the separator specified by "version_path_separator" below.
+# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
+
+# version path separator; As mentioned above, this is the character used to split
+# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
+# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
+# Valid values for version_path_separator are:
+#
+# version_path_separator = :
+# version_path_separator = ;
+# version_path_separator = space
+# version_path_separator = newline
+version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
+
+# set to 'true' to search source files recursively
+# in each "version_locations" directory
+# new in Alembic version 1.10
+# recursive_version_locations = false
+
+# the output encoding used when revision files
+# are written from script.py.mako
+# output_encoding = utf-8
+
+sqlalchemy.url = driver://user:pass@localhost/dbname
+
+
+[post_write_hooks]
+# post_write_hooks defines scripts or Python functions that are run
+# on newly generated revision scripts.  See the documentation for further
+# detail and examples
+
+# format using "black" - use the console_scripts runner, against the "black" entrypoint
+# hooks = black
+# black.type = console_scripts
+# black.entrypoint = black
+# black.options = -l 79 REVISION_SCRIPT_FILENAME
+
+# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
+# hooks = ruff
+# ruff.type = exec
+# ruff.executable = %(here)s/.venv/bin/ruff
+# ruff.options = --fix REVISION_SCRIPT_FILENAME
+
+# Logging configuration
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARNING
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARNING
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

shaapi/template/backend/app/__init__.py

@@ -0,0 +1,55 @@
+import os
+import importlib
+from typing import Iterator
+import types
+import logging
+
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+class Handlers:
+    handlers_base_path = ('backend', 'app')
+    ignored = ('__init__.py', '__pycache__','crud','schema','service')
+    paths = ('admin/api/v1', 'client/api/v1', 'mentor/api/v1', 'company/api/v1')
+    # include_dirs = ["v1"]
+
+    @classmethod
+    def __all_module_paths(cls) -> list:
+        module_paths = []
+        
+        for path in cls.paths:
+            handlers_path = f"{os.path.join(os.getcwd(), *cls.handlers_base_path)}/{path}/".replace("backend/backend","backend")
+            for root, dirs, files in os.walk(handlers_path):
+                for file in files:
+                    if file.endswith('.py') and file not in cls.ignored:
+                        relative_path = os.path.relpath(os.path.join(root, file), handlers_path)
+                        module_paths.append(os.path.join(path, relative_path))
+                
+            
+                    
+
+        return module_paths
+
+    @classmethod
+    def __module_namespace(cls, module_path: str) -> str:
+        # Normalize both separators so module resolution works on Windows
+        # (os.sep == '\\') and Linux (os.sep == '/') alike.
+        module_path = module_path.replace(os.sep, '.').replace('/', '.').replace('.py', '')
+        namespace = '%s.%s' % ('.'.join(cls.handlers_base_path), module_path)
+        return namespace
+
+    @classmethod
+    def iterator(cls) -> Iterator[types.ModuleType]:
+        for module_path in cls.__all_module_paths():
+            module_name = cls.__module_namespace(module_path)
+            try:
+                handler = importlib.import_module(module_name)
+                yield handler
+            except Exception as e:
+                logger.error(f"Erreur lors de l'importation de {module_name}: {e}")
+
+    @classmethod
+    def modules(cls) -> map:
+        return map(
+            lambda module_path: cls.__module_namespace(module_path), cls.__all_module_paths()
+        )

shaapi/template/backend/app/admin/__init__.py

@@ -0,0 +1 @@
+

shaapi/template/backend/app/admin/api/v1/auth.py

@@ -0,0 +1,59 @@
+from fastapi import APIRouter, Request, Response
+from starlette.background import BackgroundTasks
+
+from backend.app.admin.schema.user import (
+    GetCurrentUserInfoDetail,
+    # UpdatePasswordParam,
+    UserLoginSchema,
+    UserRegister
+)
+from backend.app.admin.service.auth_service import auth_service
+# from backend.app.user.service.user_service import user_service
+from backend.common.response.response_schema import ResponseModel, response_base
+from backend.common.security.jwt import DependsJwtAuth
+
+router = APIRouter(prefix="/auth", tags=["User Auth"])
+
+
+@router.post('/register', summary='registered user')
+async def register_user(request: Request, response: Response, obj: UserRegister, background_tasks: BackgroundTasks) -> ResponseModel:
+    data = await auth_service.register(request=request, response=response, obj=obj, background_tasks=background_tasks)
+    
+    return response_base.success(request=request, data=data)
+
+
+@router.post(
+    '/login',
+    summary='user login',
+    description='json format, only supports debugging in third-party api tools, e.g. postman.',
+    # dependencies=[Depends(RateLimiter(times=5, minutes=1))],
+)
+async def user_login(
+    request: Request, response: Response, obj: UserLoginSchema, background_tasks: BackgroundTasks
+) -> ResponseModel:
+    data = await auth_service.login(request=request, response=response, obj=obj, background_tasks=background_tasks)
+    return response_base.success(request=request, data=data)
+
+
+@router.post('/token/new', summary='Create a new token', dependencies=[DependsJwtAuth])
+async def create_new_token(request: Request, response: Response) -> ResponseModel:
+    data = await auth_service.new_token(request=request, response=response)
+    return response_base.success(request=request, data=data)
+
+
+@router.post('/logout', summary='user logout', dependencies=[DependsJwtAuth])
+async def user_logout(request: Request, response: Response) -> ResponseModel:
+    await auth_service.logout(request=request, response=response)
+    return response_base.success(request=request)
+
+
+@router.get('/me', summary='Get connected user profile', dependencies=[DependsJwtAuth], response_model_exclude={'password'})
+async def get_current_user(request: Request) -> ResponseModel:
+    data = GetCurrentUserInfoDetail(**request.user.model_dump())
+    return response_base.success(request=request, data=data)
+
+
+
+
+
+

shaapi/template/backend/app/admin/api/v1/casbin.py

@@ -0,0 +1,218 @@
+from typing import Annotated
+from uuid import UUID
+
+from fastapi import APIRouter, Query, Request
+
+from backend.app.admin.schema.casbin_rule import (
+    CreatePolicyParam,
+    CreateUserRoleParam,
+    DeleteAllPoliciesParam,
+    DeletePolicyParam,
+    DeleteUserRoleParam,
+    GetPolicyListDetails,
+    UpdatePolicyParam,
+)
+from backend.app.admin.service.casbin_service import casbin_service
+from backend.common.pagination import DependsPagination, paging_data
+from backend.common.response.response_schema import ResponseModel, response_base
+from backend.common.security.jwt import DependsJwtAuth
+from backend.common.security.rbac import DependsRBAC
+from backend.database.db_postgres import CurrentSession
+
+router = APIRouter(prefix='/casbin', tags=["Casbin"])
+
+
+@router.get(
+    '/',
+    summary='(Fuzzy condition) Get all permission policies with pagination',
+    dependencies=[
+        DependsJwtAuth,
+        DependsPagination,
+    ],
+)
+async def get_pagination_casbin(
+    request: Request,
+    db: CurrentSession,
+    ptype: Annotated[str | None, Query(description='Policy type, p / g')] = None,
+    sub: Annotated[str | None, Query(description='User UUID / Role')] = None,
+) :
+    casbin_select = await casbin_service.get_casbin_list(ptype=ptype, sub=sub)
+    page_data = await paging_data(db, casbin_select, GetPolicyListDetails)
+    return response_base.success(request=request, data=page_data)
+
+@router.get('/policies', summary='Get all P permission policies', dependencies=[DependsJwtAuth])
+async def get_all_policies(request: Request, role: Annotated[int | None, Query(description='Role ID')] = None) -> ResponseModel:
+    policies = await casbin_service.get_policy_list(role=role)
+    return response_base.success(request=request, data=policies)
+
+
+@router.post(
+    '/policy',
+    summary='Add P permission policy',
+    dependencies=[
+        DependsRBAC,
+    ],
+)
+async def create_policy(request: Request, p: CreatePolicyParam) -> ResponseModel:
+    """
+    P Policy:
+
+    - It is recommended to add role-based access control, which needs to be combined with adding G policies to actually have access rights. Suitable for configuring global interface access policies.<br>
+    **Format**: Role + Access Path + Access Method
+
+    - If adding user-based access control, there is no need to add G policies to actually have access rights. Suitable for configuring specific user interface access policies.<br>
+    **Format**: User UUID + Access Path + Access Method
+    """
+    data = await casbin_service.create_policy(p=p)
+    return response_base.success(request=request, data=data)
+
+
+@router.post(
+    '/policies',
+    summary='Add multiple P permission policies',
+    dependencies=[
+        DependsRBAC,
+    ],
+)
+async def create_policies(request: Request, ps: list[CreatePolicyParam]) -> ResponseModel:
+    data = await casbin_service.create_policies(ps=ps)
+    return response_base.success(request=request, data=data)
+
+
+@router.put(
+    '/policy',
+    summary='Update P permission policy',
+    dependencies=[
+        DependsRBAC,
+    ],
+)
+async def update_policy(request: Request, old: UpdatePolicyParam, new: UpdatePolicyParam) -> ResponseModel:
+    data = await casbin_service.update_policy(old=old, new=new)
+    return response_base.success(request=request, data=data)
+
+
+@router.put(
+    '/policies',
+    summary='Update multiple P permission policies',
+    dependencies=[
+        DependsRBAC,
+    ],
+)
+async def update_policies(request: Request, old: list[UpdatePolicyParam], new: list[UpdatePolicyParam]) -> ResponseModel:
+    data = await casbin_service.update_policies(old=old, new=new)
+    return response_base.success(request=request, data=data)
+
+
+@router.delete(
+    '/policy',
+    summary='Delete P permission policy',
+    dependencies=[
+        DependsRBAC,
+    ],
+)
+async def delete_policy(request: Request, p: DeletePolicyParam) -> ResponseModel:
+    data = await casbin_service.delete_policy(p=p)
+    return response_base.success(request=request, data=data)
+
+
+@router.delete(
+    '/policies',
+    summary='Delete multiple P permission policies',
+    dependencies=[
+        DependsRBAC,
+    ],
+)
+async def delete_policies(request: Request, ps: list[DeletePolicyParam]) -> ResponseModel:
+    data = await casbin_service.delete_policies(ps=ps)
+    return response_base.success(request=request, data=data)
+
+
+@router.delete(
+    '/policies/all',
+    summary='Delete all P permission policies',
+    dependencies=[
+        DependsRBAC,
+    ],
+)
+async def delete_all_policies(request: Request, sub: DeleteAllPoliciesParam) -> ResponseModel:
+    count = await casbin_service.delete_all_policies(sub=sub)
+    if count > 0:
+        return response_base.success(request=request )
+    return response_base.fail(request=request)
+
+
+@router.get('/groups', summary='Get all G permission policies', dependencies=[DependsJwtAuth])
+async def get_all_groups(request: Request) -> ResponseModel:
+    data = await casbin_service.get_group_list()
+    return response_base.success(request=request, data=data)
+
+
+@router.post(
+    '/group',
+    summary='Add G permission policy',
+    dependencies=[
+        DependsRBAC,
+    ],
+)
+async def create_group(request: Request, g: CreateUserRoleParam) -> ResponseModel:
+    """
+    G Policy (**Depends on P policy**):
+
+    - If you add role-based access control in the P policy, you also need to add group-based access control in the G policy to actually have access rights.<br>
+    **Format**: User UUID + Role
+
+    - If you add user-based access control in the P policy, there is no need to add the corresponding G policy to have access rights.<br>
+    However, you will not have all the permissions of the user role, but only the specific access rights added by the corresponding P policy.
+    """
+    data = await casbin_service.create_group(g=g)
+    return response_base.success(request=request, data=data)
+
+
+@router.post(
+    '/groups',
+    summary='Add multiple G permission policies',
+    dependencies=[
+        DependsRBAC,
+    ],
+)
+async def create_groups(request: Request, gs: list[CreateUserRoleParam]) -> ResponseModel:
+    data = await casbin_service.create_groups(gs=gs)
+    return response_base.success(request=request, data=data)
+
+
+@router.delete(
+    '/group',
+    summary='Delete G permission policy',
+    dependencies=[
+        DependsRBAC,
+    ],
+)
+async def delete_group(request: Request, g: DeleteUserRoleParam) -> ResponseModel:
+    data = await casbin_service.delete_group(g=g)
+    return response_base.success(request=request, data=data)
+
+
+@router.delete(
+    '/groups',
+    summary='Delete multiple G permission policies',
+    dependencies=[
+        DependsRBAC,
+    ],
+)
+async def delete_groups(request: Request, gs: list[DeleteUserRoleParam]) -> ResponseModel:
+    data = await casbin_service.delete_groups(gs=gs)
+    return response_base.success(request=request, data=data)
+
+
+@router.delete(
+    '/groups/all',
+    summary='Delete all G permission policies',
+    dependencies=[
+        DependsRBAC,
+    ],
+)
+async def delete_all_groups(request: Request, uuid: Annotated[UUID, Query(...)]) -> ResponseModel:
+    count = await casbin_service.delete_all_groups(uuid=uuid)
+    if count > 0:
+        return response_base.success(request=request)
+    return response_base.fail(request=request)

shaapi/template/backend/app/admin/api/v1/login_log.py

@@ -0,0 +1,63 @@
+from typing import Annotated
+
+from fastapi import APIRouter, Query, Request
+
+from backend.app.admin.schema.login_log import GetLoginLogListDetails
+from backend.app.admin.service.login_log_service import login_log_service
+from backend.common.pagination import DependsPagination, paging_data
+from backend.common.response.response_schema import ResponseModel, response_base
+from backend.common.security.jwt import DependsJwtAuth
+from backend.common.security.rbac import DependsRBAC
+from backend.database.db_postgres import CurrentSession
+
+router = APIRouter(prefix="/login_log", tags=["Login log"] )
+
+
+@router.get(
+    '/',
+    summary='(Fuzzy Criteria) Paging for Login Logs',
+    dependencies=[
+        DependsJwtAuth,
+        DependsPagination,
+    ],
+)
+async def get_pagination_login_logs(
+    request: Request,
+    db: CurrentSession,
+    username: Annotated[str | None, Query()] = None,
+    status: Annotated[int | None, Query()] = None,
+    ip: Annotated[str | None, Query()] = None,
+) -> ResponseModel:
+    log_select = await login_log_service.get_select(username=username, status=status, ip=ip)
+    page_data = await paging_data(db, log_select, GetLoginLogListDetails)
+    return response_base.success(request=request, data=page_data)
+
+
+@router.delete(
+    '/',
+    summary='(Batch) Delete Login Logs',
+    dependencies=[
+        DependsRBAC,
+        DependsJwtAuth,
+        
+    ],
+)
+async def delete_login_log(request: Request, pk: Annotated[list[int], Query(...)]) -> ResponseModel:
+    count = await login_log_service.delete(pk=pk)
+    if count > 0:
+        return response_base.success(request=request)
+    return response_base.fail(request=request)
+
+
+@router.delete(
+    '/all',
+    summary='Empty login log',
+    dependencies=[
+        DependsRBAC,
+    ],
+)
+async def delete_all_login_logs(request: Request) -> ResponseModel:
+    count = await login_log_service.delete_all()
+    if count > 0:
+        return response_base.success(request=request)
+    return response_base.fail(request=request)

shaapi/template/backend/app/admin/api/v1/opera_log.py

@@ -0,0 +1,61 @@
+from typing import Annotated
+
+from fastapi import APIRouter, Query, Request
+
+from backend.app.admin.schema.opera_log import GetOperaLogListDetails
+from backend.app.admin.service.opera_log_service import opera_log_service
+from backend.common.pagination import DependsPagination, paging_data
+from backend.common.response.response_schema import ResponseModel, response_base
+from backend.common.security.jwt import DependsJwtAuth
+from backend.common.security.rbac import DependsRBAC
+from backend.database.db_postgres import CurrentSession
+
+router = APIRouter(prefix="/opera_log", tags=["Operation Log"])
+
+
+@router.get(
+    '/',
+    summary='(Fuzzy Condition) Paging for Operation Logs',
+    dependencies=[
+        DependsJwtAuth,
+        DependsPagination,
+    ],
+)
+async def get_pagination_opera_logs(
+    request: Request,
+    db: CurrentSession,
+    username: Annotated[str | None, Query()] = None,
+    status: Annotated[int | None, Query()] = None,
+    ip: Annotated[str | None, Query()] = None,
+) -> ResponseModel:
+    log_select = await opera_log_service.get_select(username=username, status=status, ip=ip)
+    page_data = await paging_data(db, log_select, GetOperaLogListDetails)
+    return response_base.success(request=request, data=page_data)
+
+
+@router.delete(
+    '/',
+    summary='Delete (batch) operation logs',
+    dependencies=[
+        DependsRBAC,
+    ],
+)
+async def delete_opera_log(request: Request, pk: Annotated[list[int], Query(...)]) -> ResponseModel:
+    count = await opera_log_service.delete(pk=pk)
+    if count > 0:
+        return response_base.success(request=request)
+    return response_base.fail(request=request)
+
+
+@router.delete(
+    '/all',
+    summary='Delete (batch) operation log',
+    dependencies=[
+        DependsRBAC,
+    ],
+)
+async def delete_all_opera_logs(request: Request) -> ResponseModel:
+    count = await opera_log_service.delete_all()
+    if count > 0:
+        return response_base.success(request=request)
+    return response_base.fail(request=request)

shaapi/template/backend/app/admin/api/v1/role.py

@@ -0,0 +1,108 @@
+from typing import Annotated
+from fastapi import APIRouter, Path, Query, Request
+from backend.common.pagination import DependsPagination, paging_data
+from backend.database.db_postgres import CurrentSession
+from backend.utils.serializers import select_as_dict, select_list_serialize
+
+from backend.app.admin.schema.role import GetRoleListDetails, UpdateRoleParam, CreateRoleParam
+from backend.app.admin.service.role_service import role_service
+from backend.common.response.response_schema import ResponseModel, response_base
+from backend.common.security.jwt import DependsJwtAuth
+
+router = APIRouter(prefix="/role", tags=["Role"])
+
+
+@router.get("/all", summary="Get all roles", dependencies=[DependsJwtAuth])
+async def get_all_roles(request: Request,) -> ResponseModel:
+    roles = await role_service.get_all()
+    data = select_list_serialize(roles)
+    return response_base.success(request=request, data=data)
+
+
+@router.get("/{pk}/all", summary="Get all user roles", dependencies=[DependsJwtAuth])
+async def get_user_all_roles(request: Request, pk: Annotated[int, Path(...)]) -> ResponseModel:
+    roles = await role_service.get_user_roles(pk=pk)
+    data = select_list_serialize(roles)
+    return response_base.success(request=request, data=data)
+
+
+@router.get(
+    "/{pk}",
+    summary="Get role by ID",
+    dependencies=[DependsJwtAuth]
+)
+async def get_role(request: Request, pk: Annotated[int, Path(...)]) -> ResponseModel:
+    role = await role_service.get_by_id(role_id=pk)
+    data = GetRoleListDetails(**select_as_dict(role))
+    return response_base.success(request=request, data=data)
+
+
+@router.get(
+    "/",
+    summary="Get roles pagination",
+    dependencies=[
+        DependsJwtAuth,
+        DependsPagination,
+    ],
+)
+async def get_pagination_roles(
+    request: Request,
+    db: CurrentSession,
+    name: Annotated[str | None, Query()] = None,
+    data_scope: Annotated[int | None, Query()] = None,
+    status: Annotated[int | None, Query()] = None,
+) -> ResponseModel:
+    role_select = await role_service.get_select(
+        name=name, data_scope=data_scope, status=status
+    )
+    page_data = await paging_data(db, role_select, GetRoleListDetails)
+    return response_base.success(request=request, data=page_data)
+
+
+@router.post(
+    "/",
+    summary="Role creation",
+    dependencies=[
+        #     Depends(RequestPermission('sys:role:add')),
+        #     DependsRBAC,
+        DependsJwtAuth,
+    ],
+)
+async def create_role(request: Request, obj: CreateRoleParam) -> ResponseModel:
+    await role_service.create(obj=obj)
+    return response_base.success(request=request)
+
+
+@router.put(
+    "/{pk}",
+    summary="Update role",
+    dependencies=[
+        #     Depends(RequestPermission('sys:role:edit')),
+        #     DependsRBAC,
+        DependsJwtAuth,
+    ],
+)
+async def update_role(
+    request: Request,
+    pk: Annotated[int, Path(...)], obj: UpdateRoleParam
+) -> ResponseModel:
+    count = await role_service.update(pk=pk, obj=obj)
+    if count > 0:
+        return response_base.success(request=request)
+    return response_base.fail(request=request)
+
+
+@router.delete(
+    "/",
+    summary="Delete roles",
+    dependencies=[
+        #     Depends(RequestPermission('sys:role:del')),
+        #     DependsRBAC,
+        DependsJwtAuth,
+    ],
+)
+async def delete_role(request: Request, pk: Annotated[list[int], Query(...)]) -> ResponseModel:
+    count = await role_service.delete(pk=pk)
+    if count > 0:
+        return response_base.success(request=request)
+    return response_base.fail(request=request)