brilliance-admin 0.44.4__py3-none-any.whl → 0.44.6__py3-none-any.whl

brilliance_admin/exceptions.py

@@ -10,6 +10,7 @@ from brilliance_admin.utils import DataclassBase, SupportsStr
 class FieldError(DataclassBase, Exception):
     message: SupportsStr = None
     code: str | None = None
+    field_slug: str | None = None
 
     def __post_init__(self):
         if not self.message and not self.code:

brilliance_admin/integrations/sqlalchemy/table/list.py

@@ -30,12 +30,12 @@ class SQLAlchemyAdminListMixin:
 
         if list_data.ordering and ordering not in self.ordering_fields:
             msg = f'Ordering "{ordering}" is not allowed; available options: {self.ordering_fields} default_ordering: {self.default_ordering}'
-            raise FieldError(message=msg)
+            raise FieldError(message=msg, field_slug='ordering')
 
         column = getattr(self.model, ordering, None)
         if not isinstance(column, InstrumentedAttribute):
             msg = f'{type(self).__name__} ordering field "{ordering}" not found in model {self.model}'
-            raise FieldError(message=msg)
+            raise FieldError(message=msg, field_slug='ordering')
 
         return stmt.order_by(direction(column))
 
@@ -122,18 +122,10 @@ class SQLAlchemyAdminListMixin:
             )
             raise AdminAPIException(APIError(message=_('errors.filters_exception'), code='filters_exception'), status_code=500) from e
 
-        data = []
-
         try:
             async with self.db_async_session() as session:
                 total_count = await session.scalar(count_stmt)
                 records = (await session.execute(stmt)).scalars().all()
-                for record in records:
-                    line = await self.table_schema.serialize(
-                        record,
-                        extra={"record": record, "user": user},
-                    )
-                    data.append(line)
 
         except ConnectionRefusedError as e:
             logger.exception(
@@ -176,4 +168,29 @@ class SQLAlchemyAdminListMixin:
                 APIError(message=msg, code='db_error_list'), status_code=500,
             ) from e
 
+        try:
+            data = []
+            for record in records:
+                line = await self.table_schema.serialize(
+                    record,
+                    extra={"record": record, "user": user},
+                )
+                data.append(line)
+
+        except FieldError as e:
+            logger.exception(
+                'SQLAlchemy %s list %s serialize field error: %s',
+                type(self).__name__, self.model.__name__, e,
+            )
+            msg = _('serialize_error.field_error') % {'error': e.message, 'field_slug': e.field_slug}
+            raise AdminAPIException(APIError(message=msg, code='filters_exception'), status_code=500) from e
+
+        except Exception as e:
+            logger.exception(
+                'SQLAlchemy %s list %s serialize error: %s',
+                type(self).__name__, self.model.__name__, e,
+            )
+            msg = _('serialize_error.unexpected_error') % {'error': str(e)}
+            raise AdminAPIException(APIError(message=msg, code='filters_exception'), status_code=500) from e
+
         return schema.TableListResult(data=data, total_count=int(total_count or 0))

brilliance_admin/integrations/sqlalchemy/table/retrieve.py

@@ -36,18 +36,6 @@ class SQLAlchemyAdminRetrieveMixin:
         try:
             async with self.db_async_session() as session:
                 record = (await session.execute(stmt)).scalars().first()
-                data = await self.table_schema.serialize(
-                    record,
-                    extra={"record": record, "user": user},
-                )
-
-        except FieldError as e:
-            logger.exception(
-                'SQLAlchemy %s retrieve %s #%s field error: %s',
-                type(self).__name__, self.model.__name__, pk, e,
-            )
-            msg = _('errors.serialize_field_error') % {'error': e.message}
-            raise AdminAPIException(APIError(message=msg, code='filters_exception'), status_code=500) from e
 
         except Exception as e:
             logger.exception(
@@ -66,6 +54,27 @@ class SQLAlchemyAdminRetrieveMixin:
                 status_code=400,
             )
 
+        try:
+            data = await self.table_schema.serialize(
+                record,
+                extra={"record": record, "user": user},
+            )
+        except FieldError as e:
+            logger.exception(
+                'SQLAlchemy %s retrieve %s #%s serialize field error: %s',
+                type(self).__name__, self.model.__name__, pk, e,
+            )
+            msg = _('serialize_error.field_error') % {'error': e.message, 'field_slug': e.field_slug}
+            raise AdminAPIException(APIError(message=msg, code='filters_exception'), status_code=500) from e
+
+        except Exception as e:
+            logger.exception(
+                'SQLAlchemy %s list %s #%s serialize error: %s',
+                type(self).__name__, self.model.__name__, pk, e,
+            )
+            msg = _('serialize_error.unexpected_error') % {'error': str(e)}
+            raise AdminAPIException(APIError(message=msg, code='filters_exception'), status_code=500) from e
+
         logger.debug(
             '%s model %s #%s retrieved by %s',
             type(self).__name__, self.table_schema.model.__name__, pk, user.username,

brilliance_admin/locales/en.yml

@@ -15,9 +15,12 @@ errors:
   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}'
-  serialize_field_error: 'Serialize error: %(error)s'
   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>

brilliance_admin/locales/ru.yml

@@ -15,9 +15,12 @@ errors:
   filters_exception: 'Произошла неизвестная техническая ошибка при фильтрации данных.'
   method_not_allowed: 'Ошибка, данный метод недоступен.'
   filter_error: 'Проишла ошибка при фильтрации: %(error)s'
-  serialize_field_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>

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: