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

brilliance_admin/schema/table/fields/base.py

@@ -1,12 +1,14 @@
 import abc
 import datetime
-from typing import Any, ClassVar, List, Tuple
+from enum import Enum
+from typing import Any, ClassVar
 
 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
 
 
@@ -52,6 +54,8 @@ class TableField(abc.ABC, FieldSchemaData):
 class IntegerField(TableField):
     _type = 'integer'
 
+    choices: Any | None = None
+
     max_value: int | None = None
     min_value: int | None = None
 
@@ -62,8 +66,6 @@ class IntegerField(TableField):
     def generate_schema(self, user, field_slug, language_context: LanguageContext) -> FieldSchemaData:
         schema = super().generate_schema(user, field_slug, language_context)
 
-        schema.choices = self.choices
-
         if self.max_value is not None:
             schema.max_value = self.max_value
 
@@ -79,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
 
@@ -95,13 +97,12 @@ class StringField(TableField):
     min_length: int | None = None
     max_length: int | None = None
 
-    choices: List[Tuple[str, str]] | None = None
+    choices: Any | None = None
 
     def generate_schema(self, user, field_slug, language_context: LanguageContext) -> FieldSchemaData:
         schema = super().generate_schema(user, field_slug, language_context)
 
         schema.multilined = self.multilined
-        schema.choices = self.choices
         schema.ckeditor = self.ckeditor
         schema.tinymce = self.tinymce
 
@@ -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
 
@@ -227,23 +255,78 @@ class ImageField(TableField):
 class ChoiceField(TableField):
     _type = 'choice'
 
+    # Tag color available:
     # https://vuetifyjs.com/en/styles/colors/#classes
-    tag_colors: dict | None = None
+    choices: Any | None = None
 
     # https://vuetifyjs.com/en/components/chips/#color-and-variants
     variant: str = 'elevated'
     size: str = 'default'
 
+    def __post_init__(self):
+        self.choices = self.generate_choices()
+
+    def generate_choices(self):
+        if not self.choices:
+            return None
+
+        if issubclass(self.choices, Enum):
+            return [
+                {'value': c.value, 'title': c.label, 'tag_color': getattr(c, 'tag_color', None)}
+                for c in self.choices
+            ]
+
+        msg = f'Field choices is not suppored: {self.choices}'
+        raise NotImplementedError(msg)
+
+    def find_choice(self, value):
+        if not self.choices:
+            return None
+
+        return next((c for c in self.choices if c.get('value') == value), None)
+
     def generate_schema(self, user, field_slug, language_context: LanguageContext) -> FieldSchemaData:
         schema = super().generate_schema(user, field_slug, language_context)
 
         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}
+        if not value:
+            return
+
+        choice = self.find_choice(value)
+        return {
+            '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

@@ -148,9 +148,10 @@ class FieldsSchema:
             list_display=self.list_display,
         )
 
+        context = {'language_context': language_context}
         for field_slug, field in self.get_fields().items():
             field_schema: FieldSchemaData = field.generate_schema(user, field_slug, language_context)
-            fields_schema.fields[field_slug] = field_schema.to_dict(keep_none=False)
+            fields_schema.fields[field_slug] = field_schema.to_dict(keep_none=False, context=context)
 
         return fields_schema
 
@@ -158,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: