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

brilliance_admin/api/routers.py

@@ -4,7 +4,7 @@ from .views.schema import router as schema_router
 from .views.table import router as schema_table
 from .views.auth import router as schema_auth
 from .views.autocomplete import router as schema_autocomplete
-from .views.graphs import router as schema_graphs
+from .views.dashboard import router as schema_dashboard
 from .views.settings import router as schema_settings
 from .views.index import router as schema_index
 
@@ -13,6 +13,6 @@ brilliance_admin_router.include_router(schema_router)
 brilliance_admin_router.include_router(schema_table)
 brilliance_admin_router.include_router(schema_auth)
 brilliance_admin_router.include_router(schema_autocomplete)
-brilliance_admin_router.include_router(schema_graphs)
+brilliance_admin_router.include_router(schema_dashboard)
 brilliance_admin_router.include_router(schema_settings)
 brilliance_admin_router.include_router(schema_index)

brilliance_admin/api/views/autocomplete.py

@@ -23,7 +23,7 @@ async def autocomplete(request: Request, group: str, category: str, data: Autoco
     context = {'language_context': language_context}
 
     try:
-        result: AutocompleteResult = await schema_category.autocomplete(data, user, language_context)
+        result: AutocompleteResult = await schema_category.autocomplete(data, user, language_context, schema)
     except AdminAPIException as e:
         return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
     except Exception as e:

brilliance_admin/api/views/{graphs.py → dashboard.py}

@@ -4,21 +4,21 @@ from fastapi.responses import JSONResponse
 from brilliance_admin.api.utils import get_category
 from brilliance_admin.exceptions import AdminAPIException
 from brilliance_admin.schema.admin_schema import AdminSchema
-from brilliance_admin.schema.graphs.category_graphs import CategoryGraphs, GraphData, GraphsDataResult
+from brilliance_admin.schema.dashboard.category_dashboard import CategoryDashboard, DashboardData, DashboardContainer
 from brilliance_admin.translations import LanguageContext
 from brilliance_admin.utils import get_logger
 
-router = APIRouter(prefix="/graph", tags=["Category - Graph"])
+router = APIRouter(prefix="/dashboard", tags=["Category - Dashboard"])
 
 logger = get_logger()
 
 
 @router.post(path='/{group}/{category}/')
-async def graph_data(request: Request, group: str, category: str, data: GraphData) -> GraphsDataResult:
+async def dashboard_data(request: Request, group: str, category: str, data: DashboardData) -> DashboardContainer:
     schema: AdminSchema = request.app.state.schema
-    schema_category, user = await get_category(request, group, category, check_type=CategoryGraphs)
+    schema_category, user = await get_category(request, group, category, check_type=CategoryDashboard)
 
-    result: GraphsDataResult = await schema_category.get_data(data, user)
+    result: DashboardContainer = await schema_category.get_data(data, user)
 
     language_slug = request.headers.get('Accept-Language')
     language_context: LanguageContext = schema.get_language_context(language_slug)

brilliance_admin/api/views/table.py

@@ -8,7 +8,8 @@ from brilliance_admin.exceptions import AdminAPIException, APIError
 from brilliance_admin.schema import AdminSchema
 from brilliance_admin.schema.table.admin_action import ActionData, ActionResult
 from brilliance_admin.schema.table.category_table import CategoryTable
-from brilliance_admin.schema.table.table_models import CreateResult, ListData, RetrieveResult, TableListResult, UpdateResult
+from brilliance_admin.schema.table.table_models import (
+    CreateResult, ListData, RetrieveResult, TableListResult, UpdateResult)
 from brilliance_admin.translations import LanguageContext
 from brilliance_admin.utils import get_logger
 
@@ -29,7 +30,7 @@ async def table_list(request: Request, group: str, category: str, list_data: Lis
     context = {'language_context': language_context}
 
     try:
-        result: TableListResult = await schema_category.get_list(list_data, user, language_context)
+        result: TableListResult = await schema_category.get_list(list_data, user, language_context, schema)
     except AdminAPIException as e:
         return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
 
@@ -53,7 +54,7 @@ async def table_retrieve(request: Request, group: str, category: str, pk: Any) -
     context = {'language_context': language_context}
 
     try:
-        result: RetrieveResult = await schema_category.retrieve(pk, user, language_context)
+        result: RetrieveResult = await schema_category.retrieve(pk, user, language_context, schema)
     except AdminAPIException as e:
         return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
 
@@ -76,7 +77,7 @@ async def table_create(request: Request, group: str, category: str) -> CreateRes
     context = {'language_context': language_context}
 
     try:
-        result: CreateResult = await schema_category.create(await request.json(), user, language_context)
+        result: CreateResult = await schema_category.create(await request.json(), user, language_context, schema)
     except AdminAPIException as e:
         return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
 
@@ -99,7 +100,7 @@ async def table_update(request: Request, group: str, category: str, pk: Any) ->
     context = {'language_context': language_context}
 
     try:
-        result: UpdateResult = await schema_category.update(pk, await request.json(), user, language_context)
+        result: UpdateResult = await schema_category.update(pk, await request.json(), user, language_context, schema)
     except AdminAPIException as e:
         return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)
 
@@ -128,7 +129,7 @@ async def table_action(
     try:
         # pylint: disable=protected-access
         result: ActionResult = await schema_category._perform_action(
-            request, action, action_data, language_context, user,
+            request, action, action_data, language_context, user, schema,
         )
     except AdminAPIException as e:
         return JSONResponse(e.get_error().model_dump(mode='json', context=context), status_code=e.status_code)

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/__init__.py

@@ -1,5 +1,6 @@
 # pylint: disable=wildcard-import, unused-wildcard-import, unused-import
 # flake8: noqa: F405
+from .fields import SQLAlchemyRelatedField
 from .auth import SQLAlchemyJWTAdminAuthentication
 from .autocomplete import SQLAlchemyAdminAutocompleteMixin
 from .fields_schema import SQLAlchemyFieldsSchema

brilliance_admin/integrations/sqlalchemy/auth.py

@@ -54,7 +54,7 @@ class SQLAlchemyJWTAdminAuthentication(AdminAuthentication):
             logger.exception(
                 'SQLAlchemy %s login db error: %s', type(self).__name__, e,
             )
-            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=500,
@@ -122,19 +122,18 @@ class SQLAlchemyJWTAdminAuthentication(AdminAuthentication):
         try:
             async with self.db_async_session() as session:
                 result = await session.execute(stmt)
+                user = result.scalar_one_or_none()
 
         except ConnectionRefusedError as e:
             logger.exception(
                 'SQLAlchemy %s authenticate db error: %s', type(self).__name__, e,
             )
-            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=500,
             ) from e
 
-        user = result.scalar_one_or_none()
-
         if not user:
             raise AdminAPIException(
                 APIError(message="User not found", code="user_not_found"),

brilliance_admin/integrations/sqlalchemy/autocomplete.py

@@ -1,11 +1,16 @@
 from brilliance_admin.auth import UserABC
+from brilliance_admin.schema.admin_schema import AdminSchema
 from brilliance_admin.schema.table.table_models import AutocompleteData, AutocompleteResult
 from brilliance_admin.translations import LanguageContext
 
 
 class SQLAlchemyAdminAutocompleteMixin:
     async def autocomplete(
-            self, data: AutocompleteData, user: UserABC, language_context: LanguageContext,
+            self,
+            data: AutocompleteData,
+            user: UserABC,
+            language_context: LanguageContext,
+            admin_schema: AdminSchema,
     ) -> AutocompleteResult:
         form_schema = None
 
@@ -32,7 +37,11 @@ class SQLAlchemyAdminAutocompleteMixin:
         if not field:
             raise Exception(f'Field "{data.field_slug}" is not found')
 
-        async with self.db_async_session() as session:
-            results = await field.autocomplete(self.model, data, user, extra={'db_session': session})
+        results = await field.autocomplete(
+            self.model,
+            data,
+            user,
+            extra={'db_async_session': self.db_async_session},
+        )
 
         return AutocompleteResult(results=results)

brilliance_admin/integrations/sqlalchemy/fields.py

@@ -6,7 +6,7 @@ from brilliance_admin.auth import UserABC
 from brilliance_admin.exceptions import AdminAPIException, APIError, FieldError
 from brilliance_admin.schema.category import FieldSchemaData
 from brilliance_admin.schema.table.fields.base import TableField
-from brilliance_admin.schema.table.table_models import Record
+from brilliance_admin.schema.table.table_models import AutocompleteData, Record
 from brilliance_admin.translations import LanguageContext
 from brilliance_admin.translations import TranslateText as _
 from brilliance_admin.utils import DeserializeAction
@@ -43,7 +43,7 @@ class SQLAlchemyRelatedField(TableField):
     # - для доступа к связи через ORM
     #   getattr(record, rel_name)
     # - для записи и чтения связанных объектов
-    rel_name: str | None = None
+    rel_name: str | None
 
     # Класс связанной SQLAlchemy-модели.
     # Откуда берётся:
@@ -96,16 +96,15 @@ class SQLAlchemyRelatedField(TableField):
         msg = f'Cannot resolve target model for FK "{field_slug}"'
         raise AttributeError(msg)
 
-    async def autocomplete(self, model, data, user, *, extra: dict | None = None) -> List[Record]:
+    async def autocomplete(self, model, data: AutocompleteData, user, *, extra: dict | None = None) -> List[Record]:
         # pylint: disable=import-outside-toplevel
         from sqlalchemy import select
-        from sqlalchemy.sql import expression
 
-        if extra is None or extra.get('db_session') is None:
-            msg = f'SQLAlchemyRelatedField.autocomplete {type(self).__name__} requires extra["db_session"] (AsyncSession)'
+        if extra is None or extra.get('db_async_session') is None:
+            msg = f'SQLAlchemyRelatedField.autocomplete {type(self).__name__} requires extra["db_async_session"] (AsyncSession)'
             raise AttributeError(msg)
 
-        session = extra['db_session']
+        db_async_session = extra['db_async_session']
 
         results = []
 
@@ -113,21 +112,37 @@ class SQLAlchemyRelatedField(TableField):
         limit = min(150, data.limit)
         stmt = select(target_model).limit(limit)
 
+        pk = get_pk(target_model)
+        python_pk_type = pk.property.columns[0].type.python_type
+
         if data.search_string:
-            if hasattr(target_model, 'id'):
-                stmt = stmt.where(getattr(target_model, 'id') == data.search_string)
+            try:
+                value = python_pk_type(data.search_string)
+            except (ValueError, TypeError):
+                # Search string cannot be cast to primary key type, skip id filter
+                value = None
+
+            stmt = stmt.where(pk == value)
 
         # Add already selected choices
-        existed_choices = []
         if data.existed_choices:
             existed_choices = [i['key'] for i in data.existed_choices if 'key' in i]
 
-        if existed_choices and hasattr(target_model, 'id'):
-            stmt = stmt.where(getattr(target_model, 'id').in_(existed_choices) | expression.true())
+            values = []
+            for value in existed_choices:
+                try:
+                    values.append(python_pk_type(value))
+                except (ValueError, TypeError) as e:
+                    msg = f'Invalid existed_choices value "{value}" for pk {pk} python_pk_type:{python_pk_type.__name__}'
+                    raise AdminAPIException(APIError(message=msg), status_code=500) from e
+
+            stmt = stmt.where(pk.in_(values))
+
+        async with db_async_session() as session:
+            records = (await session.execute(stmt)).scalars().all()
 
-        records = (await session.execute(stmt)).scalars().all()
         for record in records:
-            results.append(Record(key=getattr(record, 'id'), title=str(record)))
+            results.append(Record(key=getattr(record, pk.key), title=str(record)))
 
         return results
 
@@ -139,20 +154,22 @@ class SQLAlchemyRelatedField(TableField):
         - value всегда scalar (None или int)
         - ORM-объект доступен через extra["record"]
         """
+        if not value:
+            return
+
         record = extra.get('record')
         if record is None:
             raise FieldError(f'Missing record in serialize context in value: {value}')
 
+        related = getattr(record, self.rel_name, None)
+
         if self.many:
-            related = getattr(record, self.rel_name, None)
             if related is None:
-                raise FieldError(f'Related field "{self.rel_name}" is missing on record {record} (many=True)')
-
+                raise FieldError(f'Many Related field "{self.rel_name}" is missing on record "{record}"')
             return [{'key': get_pk(obj), 'title': str(obj)} for obj in related]
 
-        related = getattr(record, self.rel_name, None)
         if related is None:
-            raise FieldError(f'Related field "{self.rel_name}" is missing on record (many=False)')
+            return None
 
         return {'key': get_pk(related), 'title': str(related)}
 

brilliance_admin/integrations/sqlalchemy/fields_schema.py

@@ -54,9 +54,6 @@ class SQLAlchemyFieldsSchema(schema.FieldsSchema):
                 and not col.primary_key
             )
 
-            if "choices" in info:
-                field_data["choices"] = [(c[0], c[1]) for c in info["choices"]]
-
             col_type = col.type
             try:
                 py_t = col_type.python_type
@@ -64,12 +61,16 @@ class SQLAlchemyFieldsSchema(schema.FieldsSchema):
                 py_t = None
 
             impl = getattr(attr, 'impl', None)
-            is_mutable = isinstance(impl, Mutable)
+            is_impl_mutable = isinstance(impl, Mutable)
 
             # Foreign key column
             if col.foreign_keys:
                 continue
 
+            elif "choices" in info:
+                field_data["choices"] = info['choices']
+                field_class = schema.ChoiceField
+
             elif isinstance(col_type, (sqltypes.BigInteger, sqltypes.Integer)) or py_t is int:
                 field_class = schema.IntegerField
 
@@ -97,7 +98,7 @@ class SQLAlchemyFieldsSchema(schema.FieldsSchema):
             elif isinstance(col_type, ARRAY):
                 field_class = schema.ArrayField
                 field_data["array_type"] = type(col_type.item_type).__name__.lower()
-                field_data["read_only"] = not is_mutable
+                field_data["read_only"] = is_impl_mutable or isinstance(col_type, Mutable)
 
             elif isinstance(col_type, sqltypes.NullType):
                 continue
@@ -126,6 +127,12 @@ class SQLAlchemyFieldsSchema(schema.FieldsSchema):
 
         # relationship-поля
         for rel in mapper.relationships:
+            # relationship, у которых есть локальные FK-колонки, не добавляем в схему,
+            # так как связь редактируется через scalar-поле (FK),
+            # а relationship используется только для ORM-навигации
+            if any(col.foreign_keys for col in rel.local_columns):
+                continue
+
             field_slug = rel.key
 
             field_data = {}
@@ -233,15 +240,17 @@ class SQLAlchemyFieldsSchema(schema.FieldsSchema):
         return stmt
 
     async def serialize(self, record, extra: dict, *args, **kwargs) -> dict:
-        # pylint: disable=import-outside-toplevel
-        from sqlalchemy import inspect
 
         # Convert model values to dict
-        record_data = {
-            attr.key: getattr(record, attr.key, None)
-            for attr in inspect(record).mapper.column_attrs
-            if self.get_field(attr.key)
-        }
+        record_data = {}
+
+        for slug, field in self.get_fields().items():
+            # pylint: disable=protected-access
+            if field._type == 'related':
+                record_data[slug] = record
+            else:
+                record_data[slug] = getattr(record, slug, None)
+
         return await super().serialize(record_data, extra, *args, **kwargs)
 
     def validate_incoming_data(self, data):

brilliance_admin/integrations/sqlalchemy/table/base.py

@@ -123,11 +123,11 @@ class SQLAlchemyAdminBase(SQLAlchemyAdminAutocompleteMixin, CategoryTable):
             # pylint: disable=protected-access
             if field._type == "related":
 
-                # pylint: disable=import-outside-toplevel
-                from sqlalchemy import inspect
-
-                model_attrs = [attr.key for attr in inspect(self.model).mapper.attrs]
                 if not hasattr(self.model, field.rel_name):
+                    # pylint: disable=import-outside-toplevel
+                    from sqlalchemy import inspect
+                    model_attrs = [attr.key for attr in inspect(self.model).mapper.attrs]
+
                     msg = EXCEPTION_REL_NAME.format(
                         slug=slug,
                         model_name=self.model.__name__,

brilliance_admin/integrations/sqlalchemy/table/create.py

@@ -1,6 +1,7 @@
 from brilliance_admin import schema
 from brilliance_admin.auth import UserABC
 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
@@ -16,9 +17,10 @@ class SQLAlchemyAdminCreate:
             data: dict,
             user: UserABC,
             language_context: LanguageContext,
+            admin_schema: AdminSchema,
     ) -> schema.CreateResult:
         if not self.has_create:
-            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.exc import IntegrityError
@@ -37,7 +39,7 @@ class SQLAlchemyAdminCreate:
                 type(self).__name__, self.table_schema.model.__name__, 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=500,
@@ -61,8 +63,9 @@ class SQLAlchemyAdminCreate:
                 type(self).__name__, self.table_schema.model.__name__, e,
                 extra={'data': data},
             )
+            msg = _('errors.db_error_create') % {'error_type': type(e).__name__}
             raise AdminAPIException(
-                APIError(message=_('db_error_create'), code='db_error_create'), status_code=500,
+                APIError(message=msg, code='db_error_create'), status_code=500,
             ) from e
 
         logger.info(

brilliance_admin/integrations/sqlalchemy/table/delete.py

@@ -12,7 +12,7 @@ class SQLAlchemyDeleteAction:
         base_color='red-lighten-2',
         variant='outlined',
     )
-    async def delete(self, action_data: ActionData):
+    async def delete(self, *args, action_data: ActionData, **kwargs):
         if not self.has_delete:
-            raise AdminAPIException(APIError(message=_('method_not_allowed')), status_code=500)
+            raise AdminAPIException(APIError(message=_('errors.method_not_allowed')), status_code=500)
         return ActionResult(message=ActionMessage(_('deleted_successfully')))

brilliance_admin/integrations/sqlalchemy/table/list.py

@@ -1,6 +1,7 @@
 from brilliance_admin import auth, schema
 from brilliance_admin.exceptions import AdminAPIException, APIError, FieldError
 from brilliance_admin.integrations.sqlalchemy.fields_schema import SQLAlchemyFieldsSchema
+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
@@ -30,12 +31,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))
 
@@ -88,6 +89,7 @@ class SQLAlchemyAdminListMixin:
         list_data: schema.ListData,
         user: auth.UserABC,
         language_context: LanguageContext,
+        admin_schema: AdminSchema,
     ) -> schema.TableListResult:
         # pylint: disable=import-outside-toplevel
         from sqlalchemy import exc, func, select
@@ -109,7 +111,7 @@ class SQLAlchemyAdminListMixin:
                     'list_data': list_data,
                 }
             )
-            msg = _('filter_error') % {'error': e.message}
+            msg = _('errors.filter_error') % {'error': e.message}
             raise AdminAPIException(APIError(message=msg, code='filters_exception'), status_code=500) from e
 
         except Exception as e:
@@ -120,20 +122,15 @@ class SQLAlchemyAdminListMixin:
                     'list_data': list_data,
                 }
             )
-            raise AdminAPIException(APIError(message=_('filters_exception'), code='filters_exception'), status_code=500) from e
-
-        data = []
+            msg = _('errors.filters_exception') % {
+                'error': str(e) if admin_schema.debug else type(e).__name__,
+            }
+            raise AdminAPIException(APIError(message=msg, code='filters_exception'), status_code=500) from e
 
         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(
@@ -143,7 +140,7 @@ class SQLAlchemyAdminListMixin:
                     'list_data': list_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=500,
@@ -171,8 +168,41 @@ class SQLAlchemyAdminListMixin:
                     'list_data': list_data,
                 }
             )
+            msg = _('errors.db_error_list') % {
+                'error_type': str(e) if admin_schema.debug else type(e).__name__,
+            }
             raise AdminAPIException(
-                APIError(message=_('db_error_list'), code='db_error_list'), status_code=500,
+                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='field_error'), 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) if admin_schema.debug else type(e).__name__,
+            }
+            raise AdminAPIException(APIError(message=msg, code='unexpected_error'), status_code=500) from e
+
         return schema.TableListResult(data=data, total_count=int(total_count or 0))

brilliance_admin/integrations/sqlalchemy/table/retrieve.py

@@ -1,7 +1,9 @@
 from typing import Any
 
 from brilliance_admin import auth, schema
-from brilliance_admin.exceptions import AdminAPIException, APIError
+from brilliance_admin.exceptions import AdminAPIException, APIError, FieldError
+from brilliance_admin.integrations.sqlalchemy.fields_schema import SQLAlchemyFieldsSchema
+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
@@ -12,14 +14,17 @@ logger = get_logger()
 class SQLAlchemyAdminRetrieveMixin:
     has_retrieve: bool = True
 
+    table_schema: SQLAlchemyFieldsSchema
+
     async def retrieve(
             self,
             pk: Any,
             user: auth.UserABC,
             language_context: LanguageContext,
+            admin_schema: AdminSchema,
     ) -> schema.RetrieveResult:
-        if not self.has_delete:
-            raise AdminAPIException(APIError(message=_('method_not_allowed')), status_code=500)
+        if not self.has_retrieve:
+            raise AdminAPIException(APIError(message=_('errors.method_not_allowed')), status_code=500)
 
         # pylint: disable=import-outside-toplevel
         from sqlalchemy import inspect
@@ -33,26 +38,52 @@ 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 Exception as e:
             logger.exception(
-                'SQLAlchemy %s retrieve db error: %s', type(self).__name__, e,
+                'SQLAlchemy %s retrieve %s #%s db error: %s',
+                type(self).__name__, self.model.__name__, pk, e,
             )
+            msg = _('errors.db_error_retrieve') % {
+                'error_type': str(e) if admin_schema.debug else type(e).__name__,
+            }
             raise AdminAPIException(
-                APIError(message=_('db_error_retrieve'), code='db_error_retrieve'), status_code=500,
+                APIError(message=msg, code='db_error_retrieve'), status_code=500,
             ) from e
 
         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,
             )
 
+        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='field_error'), 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) if admin_schema.debug else type(e).__name__,
+            }
+            raise AdminAPIException(APIError(message=msg, code='unexpected_error'), 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,