brilliance-admin 0.43.1__py3-none-any.whl → 0.44.12__py3-none-any.whl

brilliance_admin/integrations/sqlalchemy/table/update.py

@@ -2,6 +2,7 @@ from typing import Any
 
 from brilliance_admin import auth, schema
 from brilliance_admin.exceptions import AdminAPIException, APIError
+from brilliance_admin.schema.admin_schema import AdminSchema
 from brilliance_admin.translations import LanguageContext
 from brilliance_admin.translations import TranslateText as _
 from brilliance_admin.utils import get_logger
@@ -19,9 +20,10 @@ class SQLAlchemyAdminUpdate:
             data: dict,
             user: auth.UserABC,
             language_context: LanguageContext,
+            admin_schema: AdminSchema,
     ) -> schema.UpdateResult:
         if not self.has_update:
-            raise AdminAPIException(APIError(message=_('method_not_allowed')), status_code=500)
+            raise AdminAPIException(APIError(message=_('errors.method_not_allowed')), status_code=500)
 
         # pylint: disable=import-outside-toplevel
         from sqlalchemy import inspect
@@ -29,7 +31,7 @@ class SQLAlchemyAdminUpdate:
 
         if pk is None:
             raise AdminAPIException(
-                APIError(message=_('pk_not_found') % {'pk_name': self.pk_name}, code='pk_not_found'),
+                APIError(message=_('errors.pk_not_found') % {'pk_name': self.pk_name}, code='pk_not_found'),
                 status_code=400,
             )
 
@@ -42,7 +44,7 @@ class SQLAlchemyAdminUpdate:
             async with self.db_async_session() as session:
                 record = (await session.execute(stmt)).scalars().first()
                 if record is None:
-                    msg = _('record_not_found') % {'pk_name': self.pk_name, 'pk': pk}
+                    msg = _('errors.record_not_found') % {'pk_name': self.pk_name, 'pk': pk}
                     raise AdminAPIException(
                         APIError(message=msg, code='record_not_found'),
                         status_code=400,
@@ -59,7 +61,7 @@ class SQLAlchemyAdminUpdate:
                 type(self).__name__, self.table_schema.model.__name__, pk, e,
                 extra={'data': data},
             )
-            msg = _('connection_refused_error') % {'error': str(e)}
+            msg = _('errors.connection_refused_error') % {'error': str(e)}
             raise AdminAPIException(
                 APIError(message=msg, code='connection_refused_error'),
                 status_code=400,
@@ -83,8 +85,11 @@ class SQLAlchemyAdminUpdate:
                 type(self).__name__, self.table_schema.model.__name__, pk, e,
                 extra={'data': data}
             )
+            msg = _('errors.db_error_update') % {
+                'error_type': str(e) if admin_schema.debug else type(e).__name__,
+            }
             raise AdminAPIException(
-                APIError(message=_('db_error_update'), code='db_error_update'), status_code=500,
+                APIError(message=msg, code='db_error_update'), status_code=500,
             ) from e
 
         logger.info(

brilliance_admin/locales/en.yml

@@ -1,13 +1,26 @@
 delete: 'Delete'
 delete_confirmation_text: "Are you sure you want to delete those records?\nThis action cannot be undone."
 deleted_successfully: 'The entries were successfully deleted.'
-pk_not_found: 'The "%(pk_name)s" field was not found in the submitted data.'
-record_not_found: 'No record found for %(pk_name)s=%(pk)s.'
-db_error_create: 'Error creating a record in the database.'
-db_error_update: 'Error updating the record in the database.'
-db_error_retrieve: 'Error retrieving the record from the database.'
-db_error_list: 'Failed to retrieve table data from the database.'
-connection_refused_error: 'Database connection error: %(error)s'
+
+errors:
+  pk_not_found: 'The "%(pk_name)s" field was not found in the submitted data.'
+  record_not_found: 'No record found for %(pk_name)s=%(pk)s.'
+
+  db_error_create: 'Error creating a record in the database: %(error_type)s'
+  db_error_update: 'Error updating the record in the database: %(error_type)s'
+  db_error_retrieve: 'Error retrieving the record from the database: %(error_type)s'
+  db_error_list: 'Failed to retrieve table data from the database: %(error_type)s'
+
+  connection_refused_error: 'Database connection error: %(error)s'
+  filters_exception: 'An unknown technical error occurred while filtering data: %(error_type)s'
+  method_not_allowed: 'Error, method not allowed. This action is not permitted.'
+  filter_error: 'An error occurred during filtering: {error}'
+  bad_type_error: 'Invalid data type: %(type)s but %(expected)s expected'
+
+serialize_error:
+  field_error: 'Field %(field_slug)s serialize error: %(error)s'
+  unexpected_error: 'Unexpected serialize error: %(error)s'
+
 search_help: 'Available search fields: %(fields)s'
 sqlalchemy_search_help: |
   <b>Available search fields:</b>
@@ -17,6 +30,3 @@ sqlalchemy_search_help: |
   <b>""</b> - quotes for exact match
   <b>%%</b> - any sequence of characters
   <b>_</b> - any single character
-filters_exception: 'An unknown technical error occurred while filtering data.'
-method_not_allowed: 'Error, method not allowed. This action is not permitted.'
-filter_error: 'An error occurred during filtering: {error}'

brilliance_admin/locales/ru.yml

@@ -1,13 +1,26 @@
 delete: 'Удалить'
 delete_confirmation_text: "Вы уверены, что хотите удалить данные записи?\nДанное действие нельзя отменить."
 deleted_successfully: 'Записи успешно удалены.'
-pk_not_found: 'Поле "%(pk_name)s" не найдено среди переданных данных.'
-record_not_found: 'Запись по ключу %(pk_name)s=%(pk)s не найдена.'
-db_error_create: 'Ошибка создания записи в базе данных.'
-db_error_update: 'Ошибка обновления записи в базе данных.'
-db_error_retrieve: 'Ошибка получения записи из базы данных.'
-db_error_list: 'Ошибка получения данных таблицы из базы данных.'
-connection_refused_error: 'Ошибка подключения к базе данных: %(error)s'
+
+errors:
+  pk_not_found: 'Поле "%(pk_name)s" не найдено среди переданных данных.'
+  record_not_found: 'Запись по ключу %(pk_name)s=%(pk)s не найдена.'
+
+  db_error_create: 'Ошибка создания записи в базе данных: %(error_type)s'
+  db_error_update: 'Ошибка обновления записи в базе данных: %(error_type)s'
+  db_error_retrieve: 'Ошибка получения записи из базы данных: %(error_type)s'
+  db_error_list: 'Ошибка получения данных таблицы из базы данных: %(error_type)s'
+
+  connection_refused_error: 'Ошибка подключения к базе данных: %(error)s'
+  filters_exception: 'Произошла неизвестная техническая ошибка при фильтрации данных: %(error_type)s'
+  method_not_allowed: 'Ошибка, данный метод недоступен.'
+  filter_error: 'Проишла ошибка при фильтрации: %(error)s'
+  bad_type_error: 'Некорректный тип данных: %(type)s; ожидается %(expected)s'
+
+serialize_error:
+  field_error: 'ошибка чтения поля %(field_slug)s: %(error)s'
+  unexpected_error: 'Ошибка обработки данных: %(error)s'
+
 search_help: 'Доступные поля для поиска: %(fields)s'
 sqlalchemy_search_help: |
   <b>Доступные поля для поиска:</b>
@@ -17,6 +30,3 @@ sqlalchemy_search_help: |
   <b>""</b> - кавычки для точного совпадения
   <b>%%</b> - любая последовательность символов
   <b>_</b> - один любой символ
-filters_exception: 'Произошла неизвестная техническая ошибка при фильтрации данных.'
-method_not_allowed: 'Ошибка, данный метод недоступен.'
-filter_error: 'Проишла ошибка при фильтрации: {error}'

brilliance_admin/schema/__init__.py

@@ -1,7 +1,7 @@
 # pylint: disable=wildcard-import, unused-wildcard-import, unused-import
 # flake8: noqa: F405
 from .admin_schema import AdminSchema, AdminSchemaData
-from .category import Category
-from .graphs import *
-from .group import Group
+from .category import CategoryGroup, CategoryLink
+from .dashboard import *
 from .table import *
+from .table.category_table import CategoryTable

brilliance_admin/schema/admin_schema.py

@@ -7,11 +7,12 @@ from urllib.parse import urljoin
 from fastapi import FastAPI, Request
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.staticfiles import StaticFiles
+from pydantic import Field
 from pydantic.dataclasses import dataclass
 
 from brilliance_admin.auth import UserABC
 from brilliance_admin.docs import build_redoc_docs, build_scalar_docs
-from brilliance_admin.schema.group import Group, GroupSchemaData
+from brilliance_admin.schema.category import BaseCategory, CategorySchemaData
 from brilliance_admin.translations import LanguageContext, LanguageManager
 from brilliance_admin.utils import DataclassBase, SupportsStr
 
@@ -23,8 +24,8 @@ DEFAULT_LANGUAGES = {
 
 @dataclass
 class AdminSchemaData(DataclassBase):
-    groups: Dict[str, GroupSchemaData]
     profile: UserABC | Any
+    categories: Dict[str, CategorySchemaData] = Field(default_factory=dict)
 
     def __post_init__(self):
         if not isinstance(self.profile, UserABC):
@@ -39,6 +40,7 @@ class AdminSettingsData(DataclassBase):
     login_greetings_message: SupportsStr | None
     navbar_density: str
     languages: Dict[str, str] | None
+    main_page: str | None = None
 
 
 @dataclass
@@ -50,9 +52,11 @@ class AdminIndexContextData(DataclassBase):
 
 @dataclass
 class AdminSchema:
-    groups: List[Group]
+    categories: List[BaseCategory]
     auth: Any
 
+    main_page: str | None = None
+
     title: SupportsStr | None = 'Admin'
     description: SupportsStr | None = None
     login_greetings_message: SupportsStr | None = None
@@ -62,15 +66,17 @@ class AdminSchema:
 
     navbar_density: str = 'default'
 
-    backend_prefix = None
-    static_prefix = None
+    backend_prefix: str | None = None
+    static_prefix: str | None = None
 
     language_manager: LanguageManager | None = None
 
+    debug: bool = False
+
     def __post_init__(self):
-        for group in self.groups:
-            if not issubclass(group.__class__, Group):
-                raise TypeError(f'Group "{group}" is not instance of Group subclass')
+        for category in self.categories:
+            if not issubclass(category.__class__, BaseCategory):
+                raise TypeError(f'Root category "{category}" is not instance of BaseCategory subclass')
 
         if not self.language_manager:
             self.language_manager = LanguageManager(DEFAULT_LANGUAGES)
@@ -81,24 +87,25 @@ class AdminSchema:
     def generate_schema(self, user: UserABC, language_slug: str | None) -> AdminSchemaData:
         language_context: LanguageContext = self.get_language_context(language_slug)
 
-        groups = {}
+        result = AdminSchemaData(profile=user)
 
-        for group in self.groups:
-            if not group.slug:
-                msg = f'Category group {type(group).__name__}.slug is empty'
+        for category in self.categories:
+            if not category.slug:
+                msg = f'Category {type(category).__name__}.slug is empty'
                 raise AttributeError(msg)
 
-            groups[group.slug] = group.generate_schema(user, language_context)
+            try:
+                result.categories[category.slug] = category.generate_schema(user, language_context).to_dict(keep_none=False)
+            except Exception as e:
+                msg = f'Root category "{category.slug}" generate_schema error: {e}'
+                raise Exception(msg) from e
 
-        return AdminSchemaData(
-            groups=groups,
-            profile=user,
-        )
+        return result
 
-    def get_group(self, group_slug: str) -> Optional[Group]:
-        for group in self.groups:
-            if group.slug == group_slug:
-                return group
+    def get_group(self, group_slug: str) -> Optional[BaseCategory]:
+        for category in self.categories:
+            if category.slug == group_slug:
+                return category
 
         return None
 
@@ -114,14 +121,13 @@ class AdminSchema:
 
         return AdminSettingsData(
             title=self.title,
+            main_page=self.main_page,
             description=self.description,
             login_greetings_message=self.login_greetings_message,
             navbar_density=self.navbar_density,
             languages=languages,
         )
 
-    # pylint: disable=too-many-arguments
-    # pylint: disable=too-many-positional-arguments
     def generate_app(
             self,
             debug=False,
@@ -131,6 +137,8 @@ class AdminSchema:
             include_docs=False,
             include_redoc=False,
     ) -> FastAPI:
+        self.debug = debug
+
         # pylint: disable=unused-variable
         language_context = self.get_language_context(language_slug=None)
 

brilliance_admin/schema/category.py

@@ -4,10 +4,13 @@ from typing import Any, ClassVar, Dict, List
 from pydantic import Field
 from pydantic.dataclasses import dataclass
 from pydantic_core import core_schema
+from structlog import get_logger
 
 from brilliance_admin.auth import UserABC
 from brilliance_admin.translations import LanguageContext
-from brilliance_admin.utils import DataclassBase, SupportsStr
+from brilliance_admin.utils import DataclassBase, KwargsInitMixin, SupportsStr, humanize_field_name
+
+logger = get_logger()
 
 
 # pylint: disable=too-many-instance-attributes
@@ -30,7 +33,6 @@ class FieldSchemaData(DataclassBase):
 
     choices: List[dict] | None = None
 
-    tag_colors: dict | None = None
     variant: str | None = None
     size: str | None = None
 
@@ -93,7 +95,7 @@ class TableInfoSchemaData(DataclassBase):
 
 
 @dataclass
-class GraphInfoSchemaData(DataclassBase):
+class DashboardInfoSchemaData(DataclassBase):
     search_enabled: bool
     search_help: str | None
 
@@ -107,37 +109,56 @@ class CategorySchemaData(DataclassBase):
     icon: str | None
     type: str
 
+    categories: dict = Field(default_factory=dict)
+
     table_info: TableInfoSchemaData | None = None
-    graph_info: GraphInfoSchemaData | None = None
+    dashboard_info: DashboardInfoSchemaData | None = None
+
+    link: str | None = None
 
     def __repr__(self):
         return f'<CategorySchemaData type={self.type} "{self.title}">'
 
 
-class Category(abc.ABC):
-    slug: ClassVar[str]
-    title: ClassVar[SupportsStr | None] = None
-    description: ClassVar[SupportsStr | None] = None
+class BaseCategory(KwargsInitMixin, abc.ABC):
+    slug: str
+    title: SupportsStr | None = None
+    description: SupportsStr | None = None
 
     # https://pictogrammers.com/library/mdi/
-    icon: ClassVar[str | None] = None
+    icon: str | None = None
 
     _type_slug: ClassVar[str]
 
     def generate_schema(self, user: UserABC, language_context: LanguageContext) -> CategorySchemaData:
-        return CategorySchemaData(
-            title=language_context.get_text(self.title) or self.slug,
+        type_slug = getattr(type(self), '_type_slug', None)
+        if not type_slug:
+            msg = f'{type(self).__name__}._type_slug must be set!'
+            raise AttributeError(msg)
+
+        result = CategorySchemaData(
+            title=language_context.get_text(self.title) or humanize_field_name(self.slug),
             description=language_context.get_text(self.description),
             icon=self.icon,
-            type=self._type_slug,
+            type=type_slug,
         )
+        return result
+
+    def __init_subclass__(cls, **kwargs):
+        super().__init_subclass__(**kwargs)
+
+        if cls is BaseCategory:
+            return
+
+        if not issubclass(cls, BaseCategory):
+            raise TypeError(f'{cls.__name__} must inherit from Category')
 
     @classmethod
     def __get_pydantic_core_schema__(cls, source_type: Any, handler: Any) -> core_schema.CoreSchema:
-        def validate(v: Any) -> "Category":
+        def validate(v: Any) -> "BaseCategory":
             if isinstance(v, cls):
                 return v
-            raise TypeError(f"Expected {cls.__name__} instance")
+            raise TypeError(f"Expected {cls.__name__} instance, recieved: {type(v)} {v}")
 
         return core_schema.no_info_plain_validator_function(
             validate,
@@ -147,3 +168,56 @@ class Category(abc.ABC):
                 return_schema=core_schema.str_schema(),
             ),
         )
+
+
+class CategoryLink(BaseCategory):
+    _type_slug: str = 'link'
+
+    link: str
+
+    def generate_schema(self, user: UserABC, language_context: LanguageContext) -> CategorySchemaData:
+        result = super().generate_schema(user, language_context)
+        result.link = self.link
+        return result
+
+
+class CategoryGroup(BaseCategory):
+    _type_slug: str = 'group'
+
+    subcategories: list = Field(default_factory=list)
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        for category in self.subcategories:
+            if not isinstance(category, BaseCategory):
+                raise TypeError(f'Category "{category}" is not instance of BaseCategory subclass')
+
+    def generate_schema(self, user: UserABC, language_context: LanguageContext) -> CategorySchemaData:
+        result = super().generate_schema(user, language_context)
+
+        for category in self.subcategories:
+
+            if not category.slug:
+                msg = f'Category {type(category).__name__}.slug is empty'
+                raise AttributeError(msg)
+
+            if category.slug in result.categories:
+                exists = result.categories[category.slug]
+                msg = f'Category {type(category).__name__}.slug "{self.slug}" already registered by "{exists.title}"'
+                raise KeyError(msg)
+
+            try:
+                result.categories[category.slug] = category.generate_schema(user, language_context)
+            except Exception as e:
+                msg = f'Category "{category.slug}" {type(category)} generate_schema error: {e}'
+                raise Exception(msg) from e
+
+        return result
+
+    def get_category(self, category_slug: str):
+        for category in self.subcategories:
+            if category.slug == category_slug:
+                return category
+
+        return None

brilliance_admin/schema/dashboard/__init__.py

@@ -0,0 +1 @@
+from .category_dashboard import CategoryDashboard

brilliance_admin/schema/dashboard/category_dashboard.py

@@ -0,0 +1,87 @@
+from typing import Any, Dict, List
+
+from pydantic import BaseModel, Field, field_serializer
+
+from brilliance_admin.schema.category import BaseCategory, DashboardInfoSchemaData
+from brilliance_admin.schema.table.fields_schema import FieldsSchema
+from brilliance_admin.translations import LanguageContext
+from brilliance_admin.utils import SupportsStr
+
+
+class DashboardData(BaseModel):
+    search: str | None = None
+    filters: Dict[str, Any] = Field(default_factory=dict)
+
+
+class ChartData(BaseModel):
+    data: dict
+    options: dict
+    width: int | None = None
+    height: int = 50
+    type: str = 'line'
+
+    component_type: str = 'chart'
+
+
+class Subcard(BaseModel):
+    title: SupportsStr
+    value: SupportsStr
+    color: str | None = None
+
+
+class PeriodGraph(BaseModel):
+    title: SupportsStr
+    value: SupportsStr
+    change: int | float | None = None
+    subcards: List[Subcard] = Field(default_factory=list)
+    values: List[List[int | float]] = Field(default_factory=list)
+    vertical: List[SupportsStr] = Field(default_factory=list)
+    horizontal: List[SupportsStr] = Field(default_factory=list)
+    component_type: str = 'period_graph'
+
+    @field_serializer('horizontal', 'vertical')
+    def serialize_str_list(self, val: list) -> list:
+        return [str(v) for v in val]
+
+
+class SmallGraph(BaseModel):
+    title: SupportsStr
+    value: SupportsStr
+    change: int | float | None = None
+    points: Dict[SupportsStr, float | int] = Field(default_factory=list)
+    component_type: str = 'small_graph'
+
+
+class DashboardContainer(BaseModel):
+    cols: int | None = None
+    md: int | None = None
+    lg: int | None = None
+    sm: int | None = None
+
+    component_type: str = 'container'
+    components: List[Any] = Field(default_factory=list)
+
+
+class CategoryDashboard(BaseCategory):
+    _type_slug: str = 'dashboard'
+
+    search_enabled: bool = False
+    search_help: SupportsStr | None = None
+
+    table_filters: FieldsSchema | None = None
+
+    def generate_schema(self, user, language_context: LanguageContext) -> DashboardInfoSchemaData:
+        schema = super().generate_schema(user, language_context)
+        dashboard_info = DashboardInfoSchemaData(
+            search_enabled=self.search_enabled,
+            search_help=language_context.get_text(self.search_help),
+        )
+
+        if self.table_filters:
+            dashboard_info.table_filters = self.table_filters.generate_schema(user, language_context)
+
+        schema.dashboard_info = dashboard_info
+        return schema
+
+    async def get_data(self, data: DashboardData, user) -> DashboardContainer:
+        raise NotImplementedError('get_data is not implemented')

brilliance_admin/schema/table/category_table.py

@@ -8,8 +8,8 @@ from pydantic import Field
 
 from brilliance_admin.auth import UserABC
 from brilliance_admin.exceptions import AdminAPIException, APIError
-from brilliance_admin.schema import Category
-from brilliance_admin.schema.category import TableInfoSchemaData
+from brilliance_admin.schema.admin_schema import AdminSchema
+from brilliance_admin.schema.category import BaseCategory, TableInfoSchemaData
 from brilliance_admin.schema.table.admin_action import ActionData, ActionResult
 from brilliance_admin.schema.table.fields_schema import FieldsSchema
 from brilliance_admin.schema.table.table_models import AutocompleteData, AutocompleteResult, ListData, TableListResult
@@ -17,7 +17,7 @@ from brilliance_admin.translations import LanguageContext
 from brilliance_admin.utils import DeserializeAction, SupportsStr
 
 
-class CategoryTable(Category):
+class CategoryTable(BaseCategory):
     _type_slug: str = 'table'
 
     search_enabled: bool = False
@@ -32,6 +32,8 @@ class CategoryTable(Category):
     pk_name: str | None = None
 
     def __init__(self, *args, table_schema=None, table_filters=None, **kwargs):
+        super().__init__(*args, **kwargs)
+
         if table_schema:
             self.table_schema = table_schema
 
@@ -128,6 +130,7 @@ class CategoryTable(Category):
             action_data: ActionData,
             language_context: LanguageContext,
             user: UserABC,
+            admin_schema: AdminSchema,
     ) -> ActionResult:
         action_fn = self._get_action_fn(action)
         if action_fn is None:
@@ -154,7 +157,7 @@ class CategoryTable(Category):
 
         return result
 
-    async def autocomplete(self, data: AutocompleteData, user: UserABC) -> AutocompleteResult:
+    async def autocomplete(self, data: AutocompleteData, user: UserABC, schema: AdminSchema) -> AutocompleteResult:
         """
         Retrieves list of found options to select.
         """
@@ -162,14 +165,16 @@ class CategoryTable(Category):
 
     # pylint: disable=too-many-arguments
     @abc.abstractmethod
-    async def get_list(self, list_data: ListData, user: UserABC, language_context: LanguageContext) -> TableListResult:
+    async def get_list(
+            self, list_data: ListData, user: UserABC, language_context: LanguageContext, admin_schema: AdminSchema
+    ) -> TableListResult:
         raise NotImplementedError()
 
-#     async def retrieve(self, pk: Any, user: UserABC) -> RetrieveResult:
+#     async def retrieve(self, pk: Any, user: UserABC, language_context: LanguageContext, admin_schema: AdminSchema) -> RetrieveResult:
 #        raise NotImplementedError()
 
-#    async def create(self, data: dict, user: UserABC) -> CreateResult:
+#    async def create(self, data: dict, user: UserABC, language_context: LanguageContext, admin_schema: AdminSchema) -> CreateResult:
 #        raise NotImplementedError()
 
-#    async def update(self, pk: Any, data: dict, user: UserABC) -> UpdateResult:
+#    async def update(self, pk: Any, data: dict, user: UserABC, language_context: LanguageContext, admin_schema: AdminSchema) -> UpdateResult:
 #        raise NotImplementedError()