shaapi 0.1.0__py3-none-any.whl

shaapi/template/backend/core/registrar.py

@@ -0,0 +1,195 @@
+from contextlib import asynccontextmanager
+
+from asgi_correlation_id import CorrelationIdMiddleware
+from fastapi import Depends, FastAPI, APIRouter
+from fastapi_limiter import FastAPILimiter
+from fastapi_pagination import add_pagination
+from starlette.middleware.authentication import AuthenticationMiddleware
+
+from backend.common.exception.exception_handler import register_exception
+from backend.common.log import set_customize_logfile, setup_logging
+from backend.core.conf import settings
+from backend.core.path_conf import STATIC_DIR
+from backend.database.db_postgres import create_table
+from backend.database.db_redis import redis_client
+from backend.middleware.jwt_auth_middleware import JwtAuthMiddleware
+from backend.middleware.opera_log_middleware import OperaLogMiddleware
+from backend.middleware.state_middleware import StateMiddleware
+from backend.middleware.i18n_middleware import I18nMiddleware
+from backend.utils.demo_site import demo_site
+from backend.utils.health_check import ensure_unique_route_names, http_limit_callback
+from backend.utils.serializers import MsgSpecJSONResponse
+
+
+
+
+@asynccontextmanager
+async def register_init(app: FastAPI):
+    """
+    Start initialization
+
+    :return:
+    """
+    # Creating database tables (dev convenience). In production rely on Alembic
+    # migrations and set DB_AUTO_CREATE=false.
+    if settings.DB_AUTO_CREATE:
+        await create_table()
+    # Connecting to redis
+    await redis_client.open()
+    # Initialize limiter
+    await FastAPILimiter.init(
+        redis=redis_client,
+        prefix=settings.REQUEST_LIMITER_REDIS_PREFIX,
+        http_callback=http_limit_callback,
+    )
+
+    yield
+
+    # Closing a redis connection
+    await redis_client.close()
+    # Close limiter
+    await FastAPILimiter.close()
+
+
+def register_app(router: APIRouter, name: str = "Parse name" ) -> FastAPI:
+    # FastAPI
+    app = FastAPI(
+        title=f"[{settings.ENVIRONMENT.upper()}] {settings.FASTAPI_TITLE} {name.upper()}",
+        contact={
+            "name": "shaapi",
+            "email": "shalomtehe219@gmail.com",
+        },
+        version=settings.FASTAPI_VERSION,
+        description=settings.FASTAPI_DESCRIPTION,
+        docs_url=f"{settings.FASTAPI_DOCS_URL}",
+        redoc_url=f"{settings.FASTAPI_REDOCS_URL}",
+        openapi_url=f"{settings.FASTAPI_OPENAPI_URL}",
+        default_response_class=MsgSpecJSONResponse,
+        # NOTE: the lifespan is owned by the parent app (see backend/main.py).
+        # Starlette does NOT run the lifespan of mounted sub-applications, so
+        # shared resources (DB tables, Redis, rate limiter) are initialized once
+        # on the parent instead.
+    )
+
+    # log (computing)
+    register_logger()
+
+    # Static files
+    register_static_file(app)
+
+    # middleware
+    register_middleware(app, name)
+
+    # routing (in computer networks)
+    register_router(app, router)
+    
+    # tab window (in a web browser etc)
+    register_page(app)
+
+    # Global Exception Handling
+    register_exception(app)
+    return app
+
+
+def register_logger() -> None:
+    """
+    System Log
+
+    :return:
+    """
+    setup_logging()
+    set_customize_logfile()
+
+
+def register_static_file(app: FastAPI):
+    """
+    Static file interaction development model, production using nginx static resource service
+
+    :param app:
+    :return:
+    """
+    if settings.FASTAPI_STATIC_FILES:
+        import os
+
+        from fastapi.staticfiles import StaticFiles
+
+        if not os.path.exists(STATIC_DIR):
+            os.mkdir(STATIC_DIR)
+        app.mount("/static", StaticFiles(directory=STATIC_DIR), name="static")
+
+
+def register_middleware(app: FastAPI, name: str = "Parse name"):
+    """
+    Middleware, execution order from bottom to top
+
+    :param app:
+    :return:
+    """
+    # Metrics middleware (opt-in observability)
+    if settings.OBSERVABILITY_ENABLED:
+        from backend.utils.prometheus import PrometheusMiddleware
+
+        app.add_middleware(PrometheusMiddleware, app_name=settings.APP_NAME)
+
+    # Opera log (required)
+    app.add_middleware(OperaLogMiddleware)
+
+    # I18N translation middleware
+    app.add_middleware(I18nMiddleware)
+    
+
+    app.add_middleware(
+        AuthenticationMiddleware, backend=JwtAuthMiddleware(), on_error=JwtAuthMiddleware.auth_exception_handler
+    )
+        
+    # Access log
+    if settings.MIDDLEWARE_ACCESS:
+        from backend.middleware.access_middleware import AccessMiddleware
+
+        app.add_middleware(AccessMiddleware)
+
+    # State
+    app.add_middleware(StateMiddleware)
+
+    # Trace ID (required)
+    app.add_middleware(CorrelationIdMiddleware, validator=False)
+    
+    # CORS: Always at the end
+    if settings.MIDDLEWARE_CORS:
+        from fastapi.middleware.cors import CORSMiddleware
+
+        app.add_middleware(
+            CORSMiddleware,
+            allow_origins=settings.CORS_ALLOWED_ORIGINS,
+            allow_credentials=True,
+            allow_methods=["*"],
+            allow_headers=["*"],
+            expose_headers=settings.CORS_EXPOSE_HEADERS,
+        )
+
+
+def register_router(app: FastAPI, router: APIRouter):
+    """
+    routing
+
+    :param app: FastAPI
+    :return:
+    """
+    dependencies = [Depends(demo_site)] if settings.DEMO_MODE else None
+
+    # API
+    app.include_router(router, dependencies=dependencies)
+
+    # Extra
+    ensure_unique_route_names(app)
+    # simplify_operation_ids(app)
+
+
+def register_page(app: FastAPI):
+    """
+    paging search
+
+    :param app:
+    :return:
+    """
+    add_pagination(app)

shaapi/template/backend/crud/__init__.py

@@ -0,0 +1 @@
+

shaapi/template/backend/crud/crud_base.py

@@ -0,0 +1,35 @@
+from typing import Any
+from sqlalchemy import select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.orm import selectinload
+from sqlalchemy.sql import Select
+from sqlalchemy_crud_plus.utils import parse_filters
+from sqlalchemy_crud_plus.types import Model
+from sqlalchemy_crud_plus import CRUDPlus
+
+
+
+
+class CRUDBase(CRUDPlus[Model]):
+        
+    def get_with_relationship(self, stmt: Select, populates: list[str] = [], sub_populates: list[Any] = []) -> Select:
+        for populate in populates:
+            stmt = stmt.options(selectinload(getattr(self.model, populate)), *sub_populates)
+        
+        return stmt
+    
+        
+    async def select_model_by_column(self, session: AsyncSession, populates: list[str] = [], sub_populates: list[Any] = [], **kwargs) -> Model | None:
+        """
+        Query by column
+
+        :param session: The SQLAlchemy async session.
+        :param kwargs: Query expressions.
+        :return:
+        """
+        filters = parse_filters(self.model, **kwargs)
+        stmt = select(self.model).where(*filters)
+        stmt = self.get_with_relationship(stmt, populates=populates, sub_populates=sub_populates)
+        query = await session.execute(stmt)
+        return query.scalars().first()
+    

shaapi/template/backend/crud/crud_casbin.py

@@ -0,0 +1,46 @@
+from uuid import UUID
+
+from sqlalchemy import Select
+from sqlalchemy.ext.asyncio import AsyncSession
+from backend.crud.crud_base import CRUDBase
+
+from backend.models import CasbinRule
+from backend.app.admin.schema.casbin_rule import DeleteAllPoliciesParam
+
+
+class CRUDCasbin(CRUDBase[CasbinRule]):
+    async def get_list(self, ptype: str, sub: str) -> Select:
+        """
+        Getting a list of casbin policies
+
+        :param ptype:
+        :param sub:
+        :return:
+        """
+        return await self.select_order('id', 'desc', ptype=ptype, v0__like=f'%{sub}%')
+
+    async def delete_policies_by_sub(self, db: AsyncSession, sub: DeleteAllPoliciesParam) -> int:
+        """
+        Delete all P casbin policies for the role
+
+        :param db:
+        :param sub:
+        :return:
+        """
+        where_list = [sub.role]
+        if sub.uuid:
+            where_list.append(sub.uuid)
+        return await self.delete_model_by_column(db, allow_multiple=True, v0__mor={'eq': where_list})
+
+    async def delete_groups_by_uuid(self, db: AsyncSession, uuid: UUID) -> int:
+        """
+        Delete all G casbin policies for a user
+
+        :param db:
+        :param uuid:
+        :return:
+        """
+        return await self.delete_model_by_column(db, allow_multiple=True, v0=str(uuid))
+
+
+casbin_dao: CRUDCasbin = CRUDCasbin(CasbinRule)

shaapi/template/backend/crud/crud_login_log.py

@@ -0,0 +1,58 @@
+from sqlalchemy import Select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy_crud_plus import CRUDPlus
+
+from backend.models import LoginLog
+from backend.app.admin.schema.login_log import CreateLoginLogParam
+
+
+class CRUDLoginLog(CRUDPlus[LoginLog]):
+    async def get_list(self, username: str | None = None, status: int | None = None, ip: str | None = None) -> Select:
+        """
+        Get the list of login logs
+
+        :param username:
+        :param status:
+        :param ip:
+        :return:
+        """
+        filters = {}
+        if username is not None:
+            filters.update(username__like=f'%{username}%')
+        if status is not None:
+            filters.update(status=status)
+        if ip is not None:
+            filters.update(ip__like=f'%{ip}%')
+        return await self.select_order('created_time', 'desc', **filters)
+
+    async def create(self, db: AsyncSession, obj_in: CreateLoginLogParam) -> None:
+        """
+        Create login logs
+
+        :param db:
+        :param obj_in:
+        :return:
+        """
+        await self.create_model(db, obj_in, commit=True)
+
+    async def delete(self, db: AsyncSession, pk: list[int]) -> int:
+        """
+        Delete login logs
+
+        :param db:
+        :param pk:
+        :return:
+        """
+        return await self.delete_model_by_column(db, allow_multiple=True, id__in=pk)
+
+    async def delete_all(self, db: AsyncSession) -> int:
+        """
+        Delete all login logs
+
+        :param db:
+        :return:
+        """
+        return await self.delete_model_by_column(db, allow_multiple=True)
+
+
+login_log_dao: CRUDLoginLog = CRUDLoginLog(LoginLog)

shaapi/template/backend/crud/crud_opera_log.py

@@ -0,0 +1,58 @@
+from sqlalchemy import Select
+from sqlalchemy.ext.asyncio import AsyncSession
+from backend.crud.crud_base import CRUDBase
+
+from backend.models import OperaLog
+from backend.app.admin.schema.opera_log import CreateOperaLogParam
+
+
+class CRUDOperaLogDao(CRUDBase[OperaLog]):
+    async def get_list(self, username: str | None = None, status: int | None = None, ip: str | None = None) -> Select:
+        """
+        Getting a list of operation logs
+
+        :param username:
+        :param status:
+        :param ip:
+        :return:
+        """
+        filters = {}
+        if username is not None:
+            filters.update(username=f'%{username}%')
+        if status is not None:
+            filters.update(status=status)
+        if ip is not None:
+            filters.update(ip=f'%{ip}%')
+        return await self.select_order('created_time', 'desc', **filters)
+
+    async def create(self, db: AsyncSession, obj_in: CreateOperaLogParam) -> None:
+        """
+        Creating operation logs
+
+        :param db:
+        :param obj_in:
+        :return:
+        """
+        await self.create_model(db, obj_in)
+
+    async def delete(self, db: AsyncSession, pk: list[int]) -> int:
+        """
+        Delete operation log
+
+        :param db:
+        :param pk:
+        :return:
+        """
+        return await self.delete_model_by_column(db, allow_multiple=True, id__in=pk)
+
+    async def delete_all(self, db: AsyncSession) -> int:
+        """
+        Delete all operation logs
+
+        :param db:
+        :return:
+        """
+        return await self.delete_model_by_column(db, allow_multiple=True)
+
+
+opera_log_dao: CRUDOperaLogDao = CRUDOperaLogDao(OperaLog)

shaapi/template/backend/crud/crud_role.py

@@ -0,0 +1,128 @@
+from sqlalchemy import Sequence, desc, select
+from sqlalchemy.ext.asyncio import AsyncSession
+from sqlalchemy.sql import Select
+from backend.crud.crud_base import CRUDBase
+
+from backend.models import Role, Role
+from backend.app.admin.schema.role import (
+    CreateRoleParam,
+    UpdateRoleParam,
+)
+from backend.models.user import User
+
+
+class CRUDRole(CRUDBase[Role]):
+    async def get(self, db: AsyncSession, role_id: int) -> Role | None:
+        """
+        Getting Roles
+
+        :param db:
+        :param role_id:
+        :return:
+        """
+        return await self.select_model(db, role_id)
+
+    async def get(self, db, role_id: int) -> Role | None:
+        """
+        Get role by id
+
+        :param db:
+        :param role_id:
+        :return:
+        """
+        return await self.select_model(db, role_id)
+
+    async def get_all(self, db) -> Sequence[Role]:
+        """
+        Get all roles
+
+        :param db:
+        :return:
+        """
+        return await self.select_models(db)
+
+    async def get_user_roles(self, db, user_id: int) -> Sequence[Role]:
+        """
+        Get user roles
+
+        :param db:
+        :param user_id:
+        :return:
+        """
+        stmt = select(self.model).join(self.model.users).where(User.id == user_id)
+        roles = await db.execute(stmt)
+        return roles.scalars().all()
+
+    async def get_list(
+        self, name: str = None, data_scope: int = None, status: int = None
+    ) -> Select:
+        """
+        Get role list
+
+        :param name:
+        :param data_scope:
+        :param status:
+        :return:
+        """
+        stmt = (
+            select(self.model)
+            .order_by(desc(self.model.created_time))
+        )
+        where_list = []
+        if name:
+            where_list.append(self.model.name.like(f"%{name}%"))
+        if data_scope:
+            where_list.append(self.model.data_scope == data_scope)
+        if status is not None:
+            where_list.append(self.model.status == status)
+        if where_list:
+            stmt = stmt.where(*where_list)
+        return stmt
+
+    async def get_by_name(self, db, name: str) -> Role | None:
+        """
+        Get role by name
+
+        :param db:
+        :param name:
+        :return:
+        """
+        roles =  await self.select_model_by_column(db, name=name)
+
+        return roles
+
+    async def create(self, db, obj_in: CreateRoleParam) -> None:
+        """
+        Creating roles
+
+        :param db:
+        :param obj_in:
+        :return:
+        """
+        await self.create_model(db, obj_in)
+
+    async def update(self, db, role_id: int, obj_in: UpdateRoleParam) -> int:
+        """
+        Updating roles
+
+        :param db:
+        :param role_id:
+        :param obj_in:
+        :return:
+        """
+        return await self.update_model(db, role_id, obj_in)
+
+    async def delete(self, db, role_id: list[int]) -> int:
+        """
+        Delete roles
+
+        :param db:
+        :param role_id:
+        :return:
+        """
+        return await self.delete_model_by_column(
+            db, allow_multiple=True, id__in=role_id
+        )
+
+
+role_dao: CRUDRole = CRUDRole(Role)