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

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, humanize_field_name
+from brilliance_admin.utils import DataclassBase, KwargsInitMixin, SupportsStr, humanize_field_name
+
+logger = get_logger()
 
 
 # pylint: disable=too-many-instance-attributes
@@ -92,7 +95,7 @@ class TableInfoSchemaData(DataclassBase):
 
 
 @dataclass
-class GraphInfoSchemaData(DataclassBase):
+class DashboardInfoSchemaData(DataclassBase):
     search_enabled: bool
     search_help: str | None
 
@@ -106,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(
+        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,
@@ -146,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()

brilliance_admin/schema/table/fields/base.py

@@ -8,6 +8,7 @@ from pydantic.dataclasses import dataclass
 from brilliance_admin.exceptions import FieldError
 from brilliance_admin.schema.category import FieldSchemaData
 from brilliance_admin.translations import LanguageContext
+from brilliance_admin.translations import TranslateText as _
 from brilliance_admin.utils import DeserializeAction, SupportsStr, humanize_field_name
 
 
@@ -80,7 +81,7 @@ class IntegerField(TableField):
     async def deserialize(self, value, action: DeserializeAction, extra: dict, *args, **kwargs) -> Any:
         value = await super().deserialize(value, action, extra, *args, **kwargs)
         if value and not isinstance(value, int):
-            raise FieldError(f'bad int type: {type(value)}')
+            raise FieldError(_('errors.bad_type_error') % {'type': type(value), 'expected': 'init'})
 
         return value
 
@@ -116,7 +117,7 @@ class StringField(TableField):
     async def deserialize(self, value, action: DeserializeAction, extra: dict, *args, **kwargs) -> Any:
         value = await super().deserialize(value, action, extra, *args, **kwargs)
         if value and not isinstance(value, str):
-            raise FieldError(f'bad string type: {type(value)}')
+            raise FieldError(_('errors.bad_type_error') % {'type': type(value), 'expected': 'string'})
 
         return value
 
@@ -126,6 +127,18 @@ class BooleanField(TableField):
     _type = 'boolean'
 
 
+def _parse_iso(value: str) -> datetime.datetime:
+    if value.endswith('Z'):
+        value = value.replace('Z', '+00:00')
+
+    dt = datetime.datetime.fromisoformat(value)
+
+    if dt.tzinfo is None:
+        dt = dt.replace(tzinfo=datetime.timezone.utc)
+
+    return dt
+
+
 @dataclass
 class DateTimeField(TableField):
     _type = 'datetime'
@@ -151,28 +164,40 @@ class DateTimeField(TableField):
             return
 
         if value and not isinstance(value, (str, dict)):
-            raise FieldError(f'bad datetime type: {type(value)}')
+            raise FieldError(_('errors.bad_type_error') % {'type': type(value), 'expected': 'datetime'})
 
         if isinstance(value, str):
-            return datetime.datetime.strptime(value, self.format)
+            return _parse_iso(value)
 
         if isinstance(value, dict):
             if not value.get('from') or not value.get('to'):
-                msg = f'{type(self).__name__} value must be dict with from,to values: {value}'
-                raise FieldError(msg)
+                raise FieldError(
+                    f'{type(self).__name__} value must be dict with from,to values: {value}'
+                )
 
             return {
-                'from': datetime.datetime.strptime(value.get('from'), self.format),
-                'to': datetime.datetime.strptime(value.get('to'), self.format),
+                'from': _parse_iso(value['from']),
+                'to': _parse_iso(value['to']),
             }
 
-        raise NotImplementedError(f'Value "{value}" is not supporetd for datetime')
+        raise FieldError(_('errors.bad_type_error') % {'type': type(value), 'expected': 'datetime'})
 
 
 @dataclass
 class JSONField(TableField):
     _type = 'json'
 
+    async def deserialize(self, value, action: DeserializeAction, extra: dict, *args, **kwargs) -> Any:
+        value = await super().deserialize(value, action, extra, *args, **kwargs)
+
+        if value is None:
+            return
+
+        if not isinstance(value, (dict, list)):
+            raise FieldError(_('errors.bad_type_error') % {'type': type(value), 'expected': 'JSON'})
+
+        return value
+
 
 @dataclass
 class ArrayField(TableField):
@@ -190,8 +215,11 @@ class ArrayField(TableField):
     async def deserialize(self, value, action: DeserializeAction, extra: dict, *args, **kwargs) -> Any:
         value = await super().deserialize(value, action, extra, *args, **kwargs)
 
-        if value and not isinstance(value, list):
-            raise FieldError(f'bad array type: {type(value)}')
+        if value is None:
+            return
+
+        if not isinstance(value, list):
+            raise FieldError(_('errors.bad_type_error') % {'type': type(value), 'expected': 'Array'})
 
         return value
 
@@ -276,3 +304,29 @@ class ChoiceField(TableField):
             'value': value,
             'title': choice.get('title') or value if choice else value.capitalize(),
         }
+
+    async def deserialize(self, value, action: DeserializeAction, extra: dict, *args, **kwargs) -> Any:
+        value = await super().deserialize(value, action, extra, *args, **kwargs)
+
+        if value is None:
+            return
+
+        if isinstance(value, dict):
+            if 'value' not in value:
+                raise FieldError(
+                    f'{type(self).__name__} dict value must contain "value": {value}'
+                )
+            value = value['value']
+
+        if not isinstance(value, str):
+            raise FieldError(
+                f'{type(self).__name__} value must be str, got {type(value)}'
+            )
+
+        choice = self.find_choice(value)
+        if not choice:
+            raise FieldError(
+                f'Invalid choice value "{value}", allowed: {[c["value"] for c in self.choices or []]}'
+            )
+
+        return value

brilliance_admin/schema/table/fields_schema.py

@@ -159,7 +159,13 @@ class FieldsSchema:
         result = {}
         for field_slug, field in self.get_fields().items():
             value = data.get(field_slug)
-            result[field_slug] = await field.serialize(value, extra)
+
+            try:
+                result[field_slug] = await field.serialize(value, extra)
+            except FieldError as e:
+                e.field_slug = field_slug
+                raise e
+
         return result
 
     async def deserialize(self, data: dict, action: DeserializeAction, extra) -> dict: