brilliance-admin 0.42.0__py3-none-any.whl

admin_panel/schema/table/category_table.py

@@ -0,0 +1,175 @@
+import abc
+import asyncio
+import copy
+from typing import Awaitable, List
+
+from fastapi import HTTPException, Request
+from pydantic import Field
+
+from admin_panel.auth import UserABC
+from admin_panel.exceptions import AdminAPIException, APIError
+from admin_panel.schema import Category
+from admin_panel.schema.category import TableInfoSchemaData
+from admin_panel.schema.table.admin_action import ActionData, ActionResult
+from admin_panel.schema.table.fields_schema import FieldsSchema
+from admin_panel.schema.table.table_models import AutocompleteData, AutocompleteResult, ListData, TableListResult
+from admin_panel.translations import LanguageManager, TranslateText
+from admin_panel.utils import DeserializeAction
+
+
+class CategoryTable(Category):
+    _type_slug: str = 'table'
+
+    search_enabled: bool = False
+    search_help: str | TranslateText | None = None
+
+    table_schema: FieldsSchema = None
+    table_filters: FieldsSchema | None = None
+
+    ordering_fields: List[str] = Field(default_factory=list)
+    default_ordering: str | None = None
+
+    pk_name: str | None = None
+
+    def __init__(self, *args, table_schema=None, table_filters=None, **kwargs):
+        if table_schema:
+            self.table_schema = table_schema
+
+        if table_filters:
+            self.table_filters = table_filters
+
+        if self.slug is None:
+            msg = f'Category table attribute {type(self).__name__}.slug must be set'
+            raise Exception(msg)
+
+    @property
+    def has_retrieve(self):
+        if not self.pk_name:
+            return False
+
+        fn = getattr(self, 'retrieve', None)
+        return asyncio.iscoroutinefunction(fn)
+
+    @property
+    def has_create(self):
+        fn = getattr(self, 'create', None)
+        return asyncio.iscoroutinefunction(fn)
+
+    @property
+    def has_update(self):
+        fn = getattr(self, 'update', None)
+        return asyncio.iscoroutinefunction(fn)
+
+    def generate_schema(self, user, language_manager: LanguageManager) -> dict:
+        schema = super().generate_schema(user, language_manager)
+
+        table_schema = getattr(self, 'table_schema', None)
+        if not table_schema or not issubclass(table_schema.__class__, FieldsSchema):
+            raise AttributeError(f'Admin category {self.__class__} must have table_schema instance of FieldsSchema')
+
+        table = TableInfoSchemaData(
+            table_schema=self.table_schema.generate_schema(user, language_manager),
+            ordering_fields=self.ordering_fields,
+            default_ordering=self.default_ordering,
+
+            search_enabled=self.search_enabled,
+            search_help=language_manager.get_text(self.search_help),
+
+            pk_name=self.pk_name,
+            can_retrieve=self.has_retrieve,
+
+            can_create=self.has_create,
+            can_update=self.has_update,
+        )
+
+        if self.table_filters:
+            table.table_filters = self.table_filters.generate_schema(user, language_manager)
+
+        actions = {}
+        for attribute_name in dir(self):
+            if '__' in attribute_name:
+                continue
+
+            attribute = getattr(self, attribute_name)
+            if asyncio.iscoroutinefunction(attribute) and getattr(attribute, '__action__', False):
+                action = copy.copy(attribute.action_info)
+
+                action['title'] = language_manager.get_text(action.get('title'))
+                action['description'] = language_manager.get_text(action.get('description'))
+                action['confirmation_text'] = language_manager.get_text(action.get('confirmation_text'))
+
+                form_schema = action['form_schema']
+                if form_schema:
+                    try:
+                        action['form_schema'] = form_schema.generate_schema(user, language_manager)
+                    except Exception as e:
+                        msg = f'Action {attribute} form schema {form_schema} error: {e}'
+                        raise Exception(msg) from e
+
+                actions[attribute_name] = action
+
+        table.actions = actions
+        schema.table_info = table
+        return schema
+
+    def _get_action_fn(self, action: str) -> Awaitable | None:
+        attribute = getattr(self, action)
+        if not asyncio.iscoroutinefunction(attribute) or not getattr(attribute, '__action__', False):
+            return None
+
+        return attribute
+
+    # pylint: disable=too-many-arguments
+    # pylint: disable=too-many-positional-arguments
+    async def _perform_action(
+            self,
+            request: Request,
+            action: str,
+            action_data: ActionData,
+            language_manager: LanguageManager,
+            user: UserABC,
+    ) -> ActionResult:
+        action_fn = self._get_action_fn(action)
+        if action_fn is None:
+            raise HTTPException(status_code=404, detail=f'Action "{action}" is not found')
+
+        try:
+            form_schema = action_fn.action_info['form_schema']
+            if form_schema:
+                deserialized_data = await form_schema.deserialize(
+                    action_data.form_data,
+                    action=DeserializeAction.TABLE_ACTION,
+                    extra={'user': user, 'request': request}
+                )
+                action_data.form_data = deserialized_data
+
+            result: ActionResult = await action_fn(action_data)
+        except AdminAPIException as e:
+            raise e
+        except Exception as e:
+            raise AdminAPIException(
+                APIError(message=str(e), code='user_action_error'),
+                status_code=500,
+            ) from e
+
+        return result
+
+    async def autocomplete(self, data: AutocompleteData, user: UserABC) -> AutocompleteResult:
+        """
+        Retrieves list of found options to select.
+        """
+        raise NotImplementedError('autocomplete is not implemented')
+
+    # pylint: disable=too-many-arguments
+    @abc.abstractmethod
+    async def get_list(self, list_data: ListData, user: UserABC, language_manager: LanguageManager) -> TableListResult:
+        raise NotImplementedError()
+
+#     async def retrieve(self, pk: Any, user: UserABC) -> RetrieveResult:
+#        raise NotImplementedError()
+
+#    async def create(self, data: dict, user: UserABC) -> CreateResult:
+#        raise NotImplementedError()
+
+#    async def update(self, pk: Any, data: dict, user: UserABC) -> UpdateResult:
+#        raise NotImplementedError()

admin_panel/schema/table/fields/__init__.py

@@ -0,0 +1,5 @@
+# pylint: disable=wildcard-import, unused-wildcard-import, unused-import
+# flake8: noqa: F405
+from .base import (
+    ArrayField, BooleanField, ChoiceField, DateTimeField, FileField, ImageField, IntegerField, JSONField, StringField)
+from .function_field import FunctionField, function_field

admin_panel/schema/table/fields/base.py

@@ -0,0 +1,249 @@
+import abc
+import datetime
+from typing import Any, ClassVar, List, Tuple
+
+from pydantic.dataclasses import dataclass
+
+from admin_panel.exceptions import FieldError
+from admin_panel.schema.category import FieldSchemaData
+from admin_panel.translations import LanguageManager, TranslateText
+from admin_panel.utils import DeserializeAction, humanize_field_name
+
+
+@dataclass
+class TableField(abc.ABC, FieldSchemaData):
+    _type: ClassVar[str]
+
+    label: str | TranslateText | None = None
+    help_text: str | TranslateText | None = None
+
+    def generate_schema(self, user, field_slug, language_manager: LanguageManager) -> FieldSchemaData:
+        schema = FieldSchemaData(
+            type=self._type,
+            label=language_manager.get_text(self.label) or humanize_field_name(field_slug),
+            help_text=language_manager.get_text(self.help_text),
+            header=self.header,
+            read_only=self.read_only,
+            default=self.default,
+            required=self.required,
+        )
+
+        return schema
+
+    async def serialize(self, value, extra: dict, *args, **kwargs) -> Any:
+        return value
+
+    async def deserialize(self, value, action: DeserializeAction, extra: dict, *args, **kwargs) -> Any:
+        if self.required and value is None:
+            raise FieldError('Field is required', 'field_required')
+
+        return value
+
+    async def autocomplete(self, model, data, user):
+        raise NotImplementedError('autocomplete is not implemented')
+
+    # pylint: disable=too-many-arguments
+    # pylint: disable=too-many-positional-arguments
+    def set_deserialized_value(self, result: dict, field_slug, deserialized_value, action, extra):
+        result[field_slug] = deserialized_value
+
+
+@dataclass
+class IntegerField(TableField):
+    _type = 'integer'
+
+    max_value: int | None = None
+    min_value: int | None = None
+
+    inputmode: str | None = None
+    precision: int | None = None
+    scale: int | None = None
+
+    def generate_schema(self, user, field_slug, language_manager: LanguageManager) -> FieldSchemaData:
+        schema = super().generate_schema(user, field_slug, language_manager)
+
+        schema.choices = self.choices
+
+        if self.max_value is not None:
+            schema.max_value = self.max_value
+
+        if self.min_value is not None:
+            schema.min_value = self.min_value
+
+        schema.inputmode = self.inputmode
+        schema.precision = self.precision
+        schema.scale = self.scale
+
+        return schema
+
+    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)}')
+
+        return value
+
+
+@dataclass
+class StringField(TableField):
+    _type = 'string'
+
+    multilined: bool | None = None
+    ckeditor: bool | None = None
+    tinymce: bool | None = None
+
+    min_length: int | None = None
+    max_length: int | None = None
+
+    choices: List[Tuple[str, str]] | None = None
+
+    def generate_schema(self, user, field_slug, language_manager: LanguageManager) -> FieldSchemaData:
+        schema = super().generate_schema(user, field_slug, language_manager)
+
+        schema.multilined = self.multilined
+        schema.choices = self.choices
+        schema.ckeditor = self.ckeditor
+        schema.tinymce = self.tinymce
+
+        if self.min_length is not None:
+            schema.min_length = self.min_length
+
+        if self.max_length is not None:
+            schema.max_length = self.max_length
+
+        return schema
+
+    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)}')
+
+        return value
+
+
+@dataclass
+class BooleanField(TableField):
+    _type = 'boolean'
+
+
+@dataclass
+class DateTimeField(TableField):
+    _type = 'datetime'
+
+    format: str = '%Y-%m-%dT%H:%M:%S'
+    range: bool | None = None
+    include_date: bool | None = True
+    include_time: bool | None = True
+
+    def generate_schema(self, user, field_slug, language_manager: LanguageManager) -> FieldSchemaData:
+        schema = super().generate_schema(user, field_slug, language_manager)
+
+        schema.range = self.range
+        schema.include_date = self.include_date
+        schema.include_time = self.include_time
+
+        return schema
+
+    async def deserialize(self, value, action: DeserializeAction, extra: dict, *args, **kwargs) -> Any:
+        value = await super().deserialize(value, action, extra, *args, **kwargs)
+
+        if not value:
+            return
+
+        if value and not isinstance(value, (str, dict)):
+            raise FieldError(f'bad datetime type: {type(value)}')
+
+        if isinstance(value, str):
+            return datetime.datetime.strptime(value, self.format)
+
+        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)
+
+            return {
+                'from': datetime.datetime.strptime(value.get('from'), self.format),
+                'to': datetime.datetime.strptime(value.get('to'), self.format),
+            }
+
+        raise NotImplementedError(f'Value "{value}" is not supporetd for datetime')
+
+
+@dataclass
+class JSONField(TableField):
+    _type = 'json'
+
+
+@dataclass
+class ArrayField(TableField):
+    _type = 'array'
+
+    array_type: str | None
+
+    def generate_schema(self, user, field_slug, language_manager: LanguageManager) -> FieldSchemaData:
+        schema = super().generate_schema(user, field_slug, language_manager)
+
+        schema.array_type = self.array_type
+
+        return schema
+
+    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)}')
+
+        return value
+
+
+@dataclass
+class FileField(TableField):
+    _type = 'file'
+
+
+@dataclass
+class ImageField(TableField):
+    _type = 'image'
+
+    preview_max_height: int = 100
+    preview_max_width: int = 100
+
+    def generate_schema(self, user, field_slug, language_manager: LanguageManager) -> FieldSchemaData:
+        schema = super().generate_schema(user, field_slug, language_manager)
+
+        if self.preview_max_height is not None:
+            schema.preview_max_height = self.preview_max_height
+
+        if self.preview_max_width is not None:
+            schema.preview_max_width = self.preview_max_width
+
+        return schema
+
+    async def serialize(self, value, extra: dict, *args, **kwargs) -> Any:
+        return {'url': value}
+
+
+@dataclass
+class ChoiceField(TableField):
+    _type = 'choice'
+
+    # https://vuetifyjs.com/en/styles/colors/#classes
+    tag_colors: dict | None = None
+
+    # https://vuetifyjs.com/en/components/chips/#color-and-variants
+    variant: str = 'elevated'
+    size: str = 'default'
+
+    def generate_schema(self, user, field_slug, language_manager: LanguageManager) -> FieldSchemaData:
+        schema = super().generate_schema(user, field_slug, language_manager)
+
+        schema.choices = self.choices
+
+        schema.tag_colors = self.tag_colors
+        schema.size = self.size
+        schema.variant = self.variant
+
+        return schema
+
+    async def serialize(self, value, extra: dict, *args, **kwargs) -> Any:
+        return {'value': value, 'title': value.capitalize() if value else value}

admin_panel/schema/table/fields/function_field.py

@@ -0,0 +1,65 @@
+import asyncio
+import functools
+from typing import Any
+
+from pydantic.dataclasses import dataclass
+
+from admin_panel.exceptions import AdminAPIException, APIError
+from admin_panel.schema.table.fields.base import TableField
+from admin_panel.utils import get_logger
+
+logger = get_logger()
+
+
+def function_field(**kwargs):
+    '''
+    The same as decaring:
+    field = FunctionField(fn=attribute)
+
+    but available directly and converted after to the FunctionField
+    '''
+    def wrapper(func):
+        func.__function_field__ = True
+
+        field_type = kwargs.pop('type', None)
+        if field_type:
+            # pylint: disable=protected-access
+            kwargs['_type'] = field_type._type
+
+        func.__kwargs__ = kwargs
+
+        @functools.wraps(func)
+        async def wrapped(*args, **kwargs):
+            return await func(*args, **kwargs)
+
+        return wrapped
+
+    return wrapper
+
+
+@dataclass
+class FunctionField(TableField):
+    _type: str = 'function_field'
+    read_only = True
+
+    fn: Any = None
+
+    def __post_init__(self):
+        if not asyncio.iscoroutinefunction(self.fn):
+            msg = f'{type(self).__name__}.fn {self.fn} must be coroutine function'
+            raise AttributeError(msg)
+
+    async def serialize(self, value, extra: dict, *args, **kwargs) -> Any:
+        try:
+            return await self.fn(**extra)
+        except Exception as e:
+            logger.exception(
+                'Function field %s label=%s error from function="%s": %s',
+                type(self).__name__,
+                self.label,
+                self.fn,
+                e,
+            )
+            raise AdminAPIException(
+                APIError(message=f'Error: {e}', code='function_field_error'), status_code=400,
+            ) from e