brilliance-admin 0.42.0__py3-none-any.whl

admin_panel/__init__.py

@@ -0,0 +1,4 @@
+# pylint: disable=wildcard-import, unused-wildcard-import, unused-import
+# flake8: noqa: F405
+from admin_panel.integrations import sqlalchemy
+from admin_panel import schema

admin_panel/api/routers.py

@@ -0,0 +1,18 @@
+from fastapi import APIRouter
+
+from .views.schema import router as schema_router
+from .views.table import router as schema_table
+from .views.auth import router as schema_auth
+from .views.autocomplete import router as schema_autocomplete
+from .views.graphs import router as schema_graphs
+from .views.settings import router as schema_settings
+from .views.index import router as schema_index
+
+admin_panel_router = APIRouter()
+admin_panel_router.include_router(schema_router)
+admin_panel_router.include_router(schema_table)
+admin_panel_router.include_router(schema_auth)
+admin_panel_router.include_router(schema_autocomplete)
+admin_panel_router.include_router(schema_graphs)
+admin_panel_router.include_router(schema_settings)
+admin_panel_router.include_router(schema_index)

admin_panel/api/utils.py

@@ -0,0 +1,28 @@
+from fastapi import HTTPException
+
+from admin_panel.auth import AdminAuthentication
+
+
+async def get_user(request):
+    auth: AdminAuthentication = request.app.state.schema.auth
+    user = await auth.authenticate(request.headers)
+    return user
+
+
+async def get_category(request, group: str, category: str, check_type=None):
+    user = await get_user(request)
+
+    schema_group = request.app.state.schema.get_group(group)
+    if not schema_group:
+        raise HTTPException(status_code=404, detail="Group not found")
+
+    schema_category = schema_group.get_category(category)
+    if not schema_category:
+        raise HTTPException(status_code=404, detail="Category not found")
+
+    if check_type:
+        schema_category, user = await get_category(request, group, category)
+        if not issubclass(schema_category.__class__, check_type):
+            raise HTTPException(status_code=404, detail=f"Category {group}.{category} is not a {check_type.__name__}")
+
+    return schema_category, user

admin_panel/api/views/auth.py

@@ -0,0 +1,29 @@
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+
+from admin_panel.auth import AdminAuthentication, AuthData, AuthResult
+from admin_panel.exceptions import AdminAPIException, APIError
+from admin_panel.schema.admin_schema import AdminSchema
+from admin_panel.translations import LanguageManager
+
+router = APIRouter(prefix="/auth", tags=["Auth"])
+
+
+@router.post(
+    path='/login/',
+    responses={401: {"model": APIError}},
+)
+async def login(request: Request, auth_data: AuthData) -> AuthResult:
+    schema: AdminSchema = request.app.state.schema
+
+    language_slug = request.headers.get('Accept-Language')
+    language_manager: LanguageManager = schema.get_language_manager(language_slug)
+    context = {'language_manager': language_manager}
+
+    auth: AdminAuthentication = schema.auth
+    try:
+        result: AuthResult = await auth.login(auth_data)
+    except AdminAPIException as e:
+        return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
+
+    return JSONResponse(content=result.model_dump(mode='json', context=context))

admin_panel/api/views/autocomplete.py

@@ -0,0 +1,33 @@
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+
+from admin_panel.api.utils import get_category
+from admin_panel.exceptions import AdminAPIException
+from admin_panel.schema.admin_schema import AdminSchema
+from admin_panel.schema.table.table_models import AutocompleteData, AutocompleteResult
+from admin_panel.translations import LanguageManager
+from admin_panel.utils import get_logger
+
+router = APIRouter(prefix="/autocomplete", tags=["Autocomplete"])
+
+logger = get_logger()
+
+
+@router.post(path='/{group}/{category}/')
+async def autocomplete(request: Request, group: str, category: str, data: AutocompleteData):
+    schema: AdminSchema = request.app.state.schema
+    schema_category, user = await get_category(request, group, category)
+
+    language_slug = request.headers.get('Accept-Language')
+    language_manager: LanguageManager = schema.get_language_manager(language_slug)
+    context = {'language_manager': language_manager}
+
+    try:
+        result: AutocompleteResult = await schema_category.autocomplete(data, user, language_manager)
+    except AdminAPIException as e:
+        return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
+    except Exception as e:
+        logger.exception('Autocomplete %s.%s exceptoin: %s', e, group, category, extra={'data': data})
+        return JSONResponse({}, status_code=500)
+
+    return JSONResponse(result.model_dump(mode='json', context=context))

admin_panel/api/views/graphs.py

@@ -0,0 +1,30 @@
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+
+from admin_panel.api.utils import get_category
+from admin_panel.exceptions import AdminAPIException
+from admin_panel.schema.admin_schema import AdminSchema
+from admin_panel.schema.graphs.category_graphs import CategoryGraphs, GraphData, GraphsDataResult
+from admin_panel.translations import LanguageManager
+from admin_panel.utils import get_logger
+
+router = APIRouter(prefix="/graph", tags=["Category - Graph"])
+
+logger = get_logger()
+
+
+@router.post(path='/{group}/{category}/')
+async def graph_data(request: Request, group: str, category: str, data: GraphData) -> GraphsDataResult:
+    schema: AdminSchema = request.app.state.schema
+    schema_category, user = await get_category(request, group, category, check_type=CategoryGraphs)
+
+    result: GraphsDataResult = await schema_category.get_data(data, user)
+
+    language_slug = request.headers.get('Accept-Language')
+    language_manager: LanguageManager = schema.get_language_manager(language_slug)
+    context = {'language_manager': language_manager}
+
+    try:
+        return JSONResponse(result.model_dump(mode='json', context=context))
+    except AdminAPIException as e:
+        return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)

admin_panel/api/views/index.py

@@ -0,0 +1,38 @@
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import HTMLResponse
+from fastapi.templating import Jinja2Templates
+from jinja2 import Environment, PackageLoader, select_autoescape
+
+from admin_panel.schema import AdminSchema
+
+router = APIRouter()
+
+templates = Jinja2Templates(
+    env=Environment(
+        loader=PackageLoader("admin_panel", "templates"),
+        autoescape=select_autoescape(["html", "xml"]),
+    )
+)
+
+# Всё, что не должно попадать в SPA (можете расширять список)
+EXACT_BLOCK = {"/openapi.json"}
+PREFIX_BLOCK = ("/docs", "/redoc", "/scalar", "/static")
+
+
+@router.get('/{rest_of_path:path}', response_class=HTMLResponse, include_in_schema=False)
+async def admin_index(request: Request, rest_of_path: str):
+    '''
+    The request responds with a pre-rendered SPA served as an HTML page.
+    '''
+
+    path = "/" + rest_of_path
+    if path in EXACT_BLOCK or path.startswith(PREFIX_BLOCK):
+        raise HTTPException(status_code=404)
+
+    schema: AdminSchema = request.app.state.schema
+
+    return templates.TemplateResponse(
+        request=request,
+        name='index.html',
+        context=await schema.get_index_context_data(request),
+    )

admin_panel/api/views/schema.py

@@ -0,0 +1,29 @@
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+
+from admin_panel.auth import AdminAuthentication
+from admin_panel.exceptions import AdminAPIException, APIError
+from admin_panel.schema import AdminSchema, AdminSchemaData
+
+router = APIRouter(prefix="/schema", tags=["Main admin schema"])
+
+
+@router.get(
+    path='/',
+    responses={400: {"model": APIError}},
+)
+async def schema_handler(request: Request) -> AdminSchemaData:
+    '''
+    Request for retrieving the admin panel schema, including all sections and their contents.
+    '''
+    schema: AdminSchema = request.app.state.schema
+
+    auth: AdminAuthentication = schema.auth
+    try:
+        user = await auth.authenticate(request.headers)
+    except AdminAPIException as e:
+        return JSONResponse(e.get_error().model_dump(mode='json'), status_code=e.status_code)
+
+    language_slug = request.headers.get('Accept-Language')
+    admin_schema = schema.generate_schema(user, language_slug)
+    return admin_schema

admin_panel/api/views/settings.py

@@ -0,0 +1,29 @@
+from fastapi import APIRouter, Request
+from fastapi.responses import JSONResponse
+
+from admin_panel.exceptions import AdminAPIException, APIError
+from admin_panel.schema.admin_schema import AdminSchema, AdminSettingsData
+from admin_panel.translations import LanguageManager
+
+router = APIRouter(tags=["Settings"])
+
+
+@router.post(
+    path='/get-settings/',
+    responses={400: {"model": APIError}},
+)
+async def get_settings(request: Request) -> AdminSettingsData:
+    '''
+    API endpoint for fetching admin panel configuration, including title, description, and the list of supported languages.
+    '''
+    schema: AdminSchema = request.app.state.schema
+
+    language_slug = request.headers.get('Accept-Language')
+    language_manager: LanguageManager = schema.get_language_manager(language_slug)
+    context = {'language_manager': language_manager}
+
+    try:
+        admin_settings = await schema.get_settings(request)
+        return JSONResponse(admin_settings.model_dump(mode='json', context=context))
+    except AdminAPIException as e:
+        return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)

admin_panel/api/views/table.py

@@ -0,0 +1,136 @@
+from typing import Any
+
+from fastapi import APIRouter, HTTPException, Request
+from fastapi.responses import JSONResponse
+
+from admin_panel.api.utils import get_category
+from admin_panel.exceptions import AdminAPIException, APIError
+from admin_panel.schema import AdminSchema
+from admin_panel.schema.table.admin_action import ActionData, ActionResult
+from admin_panel.schema.table.category_table import CategoryTable
+from admin_panel.schema.table.table_models import CreateResult, ListData, RetrieveResult, TableListResult, UpdateResult
+from admin_panel.translations import LanguageManager
+from admin_panel.utils import get_logger
+
+router = APIRouter(prefix="/table", tags=["Category - Table"])
+
+logger = get_logger()
+
+
+# pylint: disable=too-many-arguments
+@router.post(path='/{group}/{category}/list/')
+async def table_list(request: Request, group: str, category: str, list_data: ListData) -> TableListResult:
+    schema: AdminSchema = request.app.state.schema
+
+    schema_category, user = await get_category(request, group, category, check_type=CategoryTable)
+
+    language_slug = request.headers.get('Accept-Language')
+    language_manager: LanguageManager = schema.get_language_manager(language_slug)
+    context = {'language_manager': language_manager}
+
+    try:
+        result: TableListResult = await schema_category.get_list(list_data, user, language_manager)
+    except AdminAPIException as e:
+        return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
+
+    try:
+        return JSONResponse(content=result.model_dump(mode='json', context=context))
+    except Exception as e:
+        logger.exception('Admin list error: %s; result: %s', e, result)
+        raise HTTPException(status_code=500, detail=f"Content error: {e}") from e
+
+
+@router.post(path='/{group}/{category}/retrieve/{pk}/')
+async def table_retrieve(request: Request, group: str, category: str, pk: Any) -> RetrieveResult:
+    schema: AdminSchema = request.app.state.schema
+
+    schema_category, user = await get_category(request, group, category, check_type=CategoryTable)
+    if not schema_category.has_retrieve:
+        raise HTTPException(status_code=404, detail=f"Category {group}.{category} is not allowed for retrive")
+
+    language_slug = request.headers.get('Accept-Language')
+    language_manager: LanguageManager = schema.get_language_manager(language_slug)
+    context = {'language_manager': language_manager}
+
+    try:
+        result: RetrieveResult = await schema_category.retrieve(pk, user, language_manager)
+    except AdminAPIException as e:
+        return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
+
+    return JSONResponse(content=result.model_dump(mode='json', context=context))
+
+
+@router.post(
+    path='/{group}/{category}/create/',
+    responses={400: {"model": APIError}},
+)
+async def table_create(request: Request, group: str, category: str) -> CreateResult:
+    schema: AdminSchema = request.app.state.schema
+
+    schema_category, user = await get_category(request, group, category, check_type=CategoryTable)
+    if not schema_category.has_create:
+        raise HTTPException(status_code=404, detail=f"Category {group}.{category} is not allowed for create")
+
+    language_slug = request.headers.get('Accept-Language')
+    language_manager: LanguageManager = schema.get_language_manager(language_slug)
+    context = {'language_manager': language_manager}
+
+    try:
+        result: CreateResult = await schema_category.create(await request.json(), user, language_manager)
+    except AdminAPIException as e:
+        return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
+
+    return JSONResponse(content=result.model_dump(mode='json', context=context))
+
+
+@router.patch(
+    path='/{group}/{category}/update/{pk}/',
+    responses={400: {"model": APIError}},
+)
+async def table_update(request: Request, group: str, category: str, pk: Any) -> UpdateResult:
+    schema: AdminSchema = request.app.state.schema
+
+    schema_category, user = await get_category(request, group, category, check_type=CategoryTable)
+    if not schema_category.has_update:
+        raise HTTPException(status_code=404, detail=f"Category {group}.{category} is not allowed for update")
+
+    language_slug = request.headers.get('Accept-Language')
+    language_manager: LanguageManager = schema.get_language_manager(language_slug)
+    context = {'language_manager': language_manager}
+
+    try:
+        result: UpdateResult = await schema_category.update(pk, await request.json(), user, language_manager)
+    except AdminAPIException as e:
+        return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
+
+    return JSONResponse(content=result.model_dump(mode='json', context=context))
+
+
+@router.post(
+    path='/{group}/{category}/action/{action}/',
+    responses={400: {"model": APIError}},
+)
+async def table_action(
+        request: Request,
+        group: str,
+        category: str,
+        action: str,
+        action_data: ActionData,
+) -> ActionResult:
+    schema: AdminSchema = request.app.state.schema
+
+    schema_category, user = await get_category(request, group, category, check_type=CategoryTable)
+
+    language_slug = request.headers.get('Accept-Language')
+    language_manager: LanguageManager = schema.get_language_manager(language_slug)
+    context = {'language_manager': language_manager}
+
+    try:
+        # pylint: disable=protected-access
+        result: ActionResult = await schema_category._perform_action(
+            request, action, action_data, language_manager, user,
+        )
+    except AdminAPIException as e:
+        return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
+
+    return JSONResponse(content=result.model_dump(mode='json', context=context))

admin_panel/auth.py

@@ -0,0 +1,32 @@
+import abc
+
+from pydantic import BaseModel
+from pydantic.dataclasses import dataclass
+from admin_panel.utils import DataclassBase
+
+
+@dataclass
+class UserABC(DataclassBase, abc.ABC):
+    username: str
+
+
+class AuthData(BaseModel):
+    username: str
+    password: str
+
+
+class UserResult(BaseModel):
+    username: str
+
+
+class AuthResult(BaseModel):
+    token: str
+    user: UserResult
+
+
+class AdminAuthentication(abc.ABC):
+    async def login(self, data: AuthData) -> AuthResult:
+        raise NotImplementedError('Login is not implemented')
+
+    async def authenticate(self, headers: dict) -> UserABC:
+        raise NotImplementedError('authenticate is not implemented')

admin_panel/docs.py

@@ -0,0 +1,37 @@
+from fastapi import APIRouter, FastAPI, Request
+from fastapi.openapi.docs import get_redoc_html
+from fastapi.responses import HTMLResponse
+
+
+def build_scalar_docs(app: FastAPI) -> APIRouter:
+    # pylint: disable=import-outside-toplevel
+    from scalar_fastapi import get_scalar_api_reference
+
+    router = APIRouter()
+
+    @router.get("/scalar", include_in_schema=False)
+    async def scalar_docs(request: Request):
+        root_path = request.scope.get("root_path", "")
+        openapi_url = f"{root_path}{app.openapi_url}"
+        return get_scalar_api_reference(
+            openapi_url=openapi_url,
+        )
+
+    return router
+
+
+# https://cdn.jsdelivr.net/npm/redoc/bundles/redoc.standalone.js
+def build_redoc_docs(app, redoc_url):
+    router = APIRouter()
+
+    @router.get(redoc_url, include_in_schema=False)
+    async def redoc(request: Request) -> HTMLResponse:
+        root_path = request.scope.get("root_path", "")
+        openapi_url = f"{root_path}{app.openapi_url}"
+        return get_redoc_html(
+            openapi_url=openapi_url,
+            title=f"{request.app.state.schema.title} - ReDoc",
+            redoc_js_url="https://cdn.jsdelivr.net/npm/redoc/bundles/redoc.standalone.js",
+        )
+
+    return router

admin_panel/exceptions.py

@@ -0,0 +1,38 @@
+from typing import Dict
+
+from pydantic import Field
+from pydantic.dataclasses import dataclass
+
+from admin_panel.translations import TranslateText
+from admin_panel.utils import DataclassBase
+
+
+@dataclass
+class FieldError(DataclassBase, Exception):
+    message: str | TranslateText = None
+    code: str | None = None
+
+    def __post_init__(self):
+        if not self.message and not self.code:
+            msg = 'FieldError must contain message or code'
+            raise AttributeError(msg)
+
+
+@dataclass
+class APIError(DataclassBase):
+    message: str | TranslateText | None = None
+    code: str | None = None
+    field_errors: Dict[str, FieldError] | None = None
+
+
+@dataclass
+class AdminAPIException(DataclassBase, Exception):
+    error: APIError = Field(default_factory=APIError)
+    status_code: int = 400
+    error_code: str | None = None
+
+    def __str__(self):
+        return str(self.error)
+
+    def get_error(self) -> APIError:
+        return self.error

admin_panel/integrations/sqlalchemy/__init__.py

@@ -0,0 +1,6 @@
+# pylint: disable=wildcard-import, unused-wildcard-import, unused-import
+# flake8: noqa: F405
+from .auth import SQLAlchemyJWTAdminAuthentication
+from .autocomplete import SQLAlchemyAdminAutocompleteMixin
+from .fields_schema import SQLAlchemyFieldsSchema
+from .table import *

admin_panel/integrations/sqlalchemy/auth.py

@@ -0,0 +1,144 @@
+from admin_panel.auth import AdminAuthentication, AuthData, AuthResult, UserABC, UserResult
+from admin_panel.exceptions import AdminAPIException, APIError
+from admin_panel.translations import TranslateText as _
+from admin_panel.utils import get_logger
+
+logger = get_logger()
+
+
+class SQLAlchemyJWTAdminAuthentication(AdminAuthentication):
+    secret: str
+    db_async_session = None
+    user_model = None
+    pk_name = None
+
+    def __init__(self, secret: str, db_async_session, user_model, pk_name='id'):
+        self.pk_name = pk_name
+        self.secret = secret
+        self.db_async_session = db_async_session
+        self.user_model = user_model
+
+        if not isinstance(secret, str) or not secret:
+            raise ValueError("JWT secret must be a non-empty string")
+
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy.inspection import inspect
+        try:
+            import jwt
+        except ImportError as e:
+            msg = "PyJWT is not installed. Install it with: pip install pyjwt"
+            raise RuntimeError(msg) from e
+
+        assert hasattr(jwt, "encode"), "PyJWT is not installed"
+
+        mapper = inspect(user_model)
+        columns = {col.key for col in mapper.columns}
+
+        required = {self.pk_name, "username", "is_admin"}
+        missing = required - columns
+
+        if missing:
+            msg = f"user_model is missing required columns: {', '.join(sorted(missing))}"
+            raise ValueError(msg)
+
+    async def login(self, data: AuthData) -> AuthResult:
+        # pylint: disable=import-outside-toplevel
+        from sqlalchemy import select
+
+        stmt = select(self.user_model).where(self.user_model.username == data.username)
+        try:
+            async with self.db_async_session() as session:
+                result = await session.execute(stmt)
+
+        except ConnectionRefusedError as e:
+            logger.exception(
+                'SQLAlchemy %s login db error: %s', type(self).__name__, e,
+            )
+            msg = _('connection_refused_error') % {'error': str(e)}
+            raise AdminAPIException(
+                APIError(message=msg, code='connection_refused_error'),
+                status_code=500,
+            ) from e
+
+        user = result.scalar_one_or_none()
+
+        if not user:
+            raise AdminAPIException(APIError(code="user_not_found"), status_code=401)
+
+        if not user.is_admin:
+            raise AdminAPIException(APIError(code="not_an_admin"), status_code=401)
+
+        return AuthResult(
+            token=self.get_token(user),
+            user=UserResult(username=user.username),
+        )
+
+    def get_token(self, user):
+        # pylint: disable=import-outside-toplevel
+        import jwt
+
+        return jwt.encode(
+            {"user_pk": str(user.id)},
+            self.secret,
+            algorithm="HS256",
+        )
+
+    async def authenticate(self, headers: dict) -> UserABC:
+        # pylint: disable=import-outside-toplevel
+        import jwt
+        from sqlalchemy import inspect, select
+
+        token = headers.get("Authorization")
+        if not token:
+            raise AdminAPIException(
+                APIError(message="Token is not presented"),
+                status_code=401,
+            )
+
+        token = token.replace("Token ", "")
+
+        try:
+            payload = jwt.decode(token, self.secret, algorithms=["HS256"])
+        except jwt.exceptions.DecodeError as e:
+            raise AdminAPIException(
+                APIError(message="Token decoding error", code="token_error"),
+                status_code=401,
+            ) from e
+
+        user_pk = payload.get("user_pk")
+        if not user_pk:
+            raise AdminAPIException(
+                APIError(message="Invalid token payload", code="token_error"),
+                status_code=401,
+            )
+
+        col = inspect(self.user_model).mapper.columns[self.pk_name]
+        python_type = col.type.python_type
+
+        stmt = select(self.user_model).where(
+            getattr(self.user_model, self.pk_name) == python_type(user_pk),
+            self.user_model.is_admin.is_(True),
+        )
+        try:
+            async with self.db_async_session() as session:
+                result = await session.execute(stmt)
+
+        except ConnectionRefusedError as e:
+            logger.exception(
+                'SQLAlchemy %s authenticate db error: %s', type(self).__name__, e,
+            )
+            msg = _('connection_refused_error') % {'error': str(e)}
+            raise AdminAPIException(
+                APIError(message=msg, code='connection_refused_error'),
+                status_code=500,
+            ) from e
+
+        user = result.scalar_one_or_none()
+
+        if not user:
+            raise AdminAPIException(
+                APIError(message="User not found", code="user_not_found"),
+                status_code=401,
+            )
+
+        return user