fastgenerateapi 1.2.13__tar.gz → 1.2.15__tar.gz

{fastgenerateapi-1.2.13 → fastgenerateapi-1.2.15}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fastgenerateapi
-Version: 1.2.13
+Version: 1.2.15
 Summary: FastAPIView Class View
 Author: ShiLiang
 Author-email: 2509144896@qq.com

{fastgenerateapi-1.2.13 → fastgenerateapi-1.2.15}/fastgenerateapi/__init__.py

@@ -27,3 +27,10 @@ from fastgenerateapi.channel.consumer import Consumer
 # 模型相关类
 from fastgenerateapi.pydantic_utils.base_model import model_config, BaseModel, IdList
 
+# 工具相关
+from fastgenerateapi.api_view.mixin.utils.docx_util import DocxUtil
+from fastgenerateapi.api_view.mixin.utils.file_util import FileUtil
+from fastgenerateapi.api_view.mixin.utils.pdf_util import PdfUtil
+from fastgenerateapi.api_view.mixin.utils.xlsx_util import XlsxUtil
+from fastgenerateapi.api_view.mixin.utils.zip_util import ZipUtil
+

{fastgenerateapi-1.2.13 → fastgenerateapi-1.2.15}/fastgenerateapi/__version__.py

@@ -8,7 +8,7 @@
 #                                                  d8888P
 
 
-VERSION = (1, 2, 13)
+VERSION = (1, 2, 15)
 
 __version__ = '.'.join(map(str, VERSION))
 

{fastgenerateapi-1.2.13 → fastgenerateapi-1.2.15}/fastgenerateapi/api_view/base_view.py

@@ -1,7 +1,7 @@
 import time
 import uuid
 from copy import copy
-from typing import Optional, Type, List, Union, Sequence, Dict
+from typing import Optional, Type, List, Union, Sequence, Dict, Any
 from urllib.parse import parse_qs
 
 from fastapi import params
@@ -24,7 +24,7 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
 
     prefix: Optional[str] = None  # 路由追加后缀
     model_class: Optional[Type[Model]] = None  # 数据库模型
-    prefetch_related_fields: Union[None, dict] = None
+    prefetch_related_fields: Optional[dict] = None
     is_with_prefetch: Optional[bool] = False
     response_schema: Optional[Type[BaseModel]] = None  # 通用返回序列化
     dependencies: Optional[Sequence[params.Depends]] = None
@@ -98,6 +98,8 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
 
     @staticmethod
     async def setattr_model(model: Model, prefetch_related_fields, *args, **kwargs) -> Model:
+        if not prefetch_related_fields:
+            return model
         for key, value_list in prefetch_related_fields.items():
             if value_list is None:
                 continue
@@ -149,6 +151,8 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
             model_class: Type[Model],
             model: Union[Model, None] = None,
             check_ignore_error_fields: List[str] = None,
+            error_format: Optional[str] = None,
+            error_value_list: Optional[List[str]] = None,
     ):
         """
         校验模型中设置了 唯一索引和联合唯一索引 的字段
@@ -156,6 +160,8 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
         :param model_class: 数据库模型
         :param model: 修改前的数据，用于判断是否修改了字段，当唯一字段与数据data_dict一致时，不会做校验
         :param check_ignore_error_fields: 错误提示忽略字段，会合并类上的字段
+        :param error_format: 错误格式，例如： "错误：输入年龄 '{}' 无效！合法范围是 {}-{} 岁"
+        :param error_value_list: 错误字段列表 ，例如：[input_age, min_age, max_age]
         :return:
         """
         check_unique_fields = self._get_unique_fields(model_class)
@@ -193,16 +199,27 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
                         is_equal = False
                         description_fields.append(unique_together_field)
                         filter_fields[unique_together_field] = unique_together_field_value
+                    elif unique_together_field == settings.app_settings.WHETHER_DELETE_FIELD:
+                        if settings.app_settings.DELETE_FIELD_TYPE  == "time":
+                            filter_fields[unique_together_field] = 0
+                        else:
+                            filter_fields[unique_together_field] = True
             if is_equal:
                 continue
 
             if await model_class.filter(**filter_fields).first():
+                if error_format and error_value_list:
+                    return self.error(
+                        status_code=422,
+                        msg=error_format.format(*[data_dict[k] for k in error_value_list])
+                    )
                 if settings.app_settings.WHETHER_DELETE_FIELD in description_fields:
                     description_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
                 for ignore_error_field in ignore_error_field_list:
                     if ignore_error_field in description_fields:
                         description_fields.remove(ignore_error_field)
                 return self.error(
+                    status_code=422,
                     msg=f"{self.get_field_description(model_class, description_fields)}已存在相同值：{[filter_fields.get(field) for field in description_fields]}"
                 )
 
@@ -214,6 +231,23 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
             result[key] = val[0]
         return result
 
+    def _get_extra_related_schema(self):
+        """
+        prefetch_related_fields 转换为 extra_include 的参数
+        :return:
+        """
+        schema_include = []
+        for key, value in self.prefetch_related_fields.items():
+            if not value:
+                schema_include.append([key, Optional[Any]])
+            elif type(value) in [list, tuple, set]:
+                for val in value:
+                    val_str = val
+                    if type(val) in [list, tuple, set]:
+                        val_str = val[0]
+                    schema_include.append(key + "__" + val_str)
+        return schema_include
+
     def get_response_schema(self):
         """
         如果response_schema不存在，则生成
@@ -222,13 +256,7 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
         if not self.response_schema:
             get_one_schema_include = []
             if self.is_with_prefetch and self.prefetch_related_fields:
-                for key, value in self.prefetch_related_fields.items():
-                    if value and type(value) in [list, tuple, set]:
-                        for val in value:
-                            val_str = val
-                            if type(val) in [list, tuple, set]:
-                                val_str = val[0]
-                            get_one_schema_include.append(key + "__" + val_str)
+                get_one_schema_include = self._get_extra_related_schema()
             self.response_schema = get_one_schema_factory(self.model_class, extra_include=get_one_schema_include)
 
         return self.response_schema

{fastgenerateapi-1.2.13 → fastgenerateapi-1.2.15}/fastgenerateapi/api_view/delete_filter_view.py

@@ -11,8 +11,9 @@ from tortoise.transactions import atomic
 
 from fastgenerateapi.api_view.base_view import BaseView
 from fastgenerateapi.data_type.data_type import CALLABLE, DEPENDENCIES
-from fastgenerateapi.deps import filter_params_deps
-from fastgenerateapi.schemas_factory import response_factory, get_one_schema_factory
+from fastgenerateapi.deps.filter_params_deps import filter_json_deps
+from fastgenerateapi.pydantic_utils.base_model import IdList, SearchPydantic
+from fastgenerateapi.schemas_factory import response_factory
 from fastgenerateapi.settings.all_settings import settings
 
 
@@ -28,22 +29,28 @@ class DeleteFilterView(BaseView):
     """
 
     @atomic()
-    async def destroy_filter(self, search: str, filters: dict, *args, **kwargs):
+    async def destroy_filter(self, search: str, request_data, filters: dict, *args, **kwargs):
         queryset = await self.get_queryset(search=search, filters=filters, *args, **kwargs)
-
+        queryset = await self.get_del_filter_queryset(queryset, request_data=request_data, *args, **kwargs)
         await self.delete_queryset(queryset)
 
         return
 
+    async def get_del_filter_queryset(self, queryset, request_data, *args, **kwargs):
+        queryset = queryset.filter(id__in=request_data.id_list)
+        return queryset
+
     def _delete_filter_decorator(self, *args: Any, **kwargs: Any) -> DecoratedCallable:
         async def route(
                 request: Request,
-                search: str = Query(default="", description="搜索"),
-                filters: dict = Depends(filter_params_deps(model_class=self.model_class, fields=self.filter_fields)),
+                search: SearchPydantic,
+                request_data: IdList,
+                filters: dict = Depends(filter_json_deps(model_class=self.model_class, fields=self.filter_fields)),
                 token: Optional[str] = Depends(OAuth2PasswordBearer(tokenUrl="token", auto_error=False)),
         ) -> JSONResponse:
             data = await self.destroy_filter(
-                search=search,
+                search=search.search,
+                request_data=request_data,
                 filters=filters,
                 request=request,
                 token=token,

{fastgenerateapi-1.2.13 → fastgenerateapi-1.2.15}/fastgenerateapi/api_view/get_all_view.py

@@ -7,6 +7,7 @@ from fastapi.types import DecoratedCallable
 from fastapi_cache import JsonCoder
 from fastapi_cache.decorator import cache
 from pydantic import BaseModel
+from starlette._utils import is_async_callable
 from starlette.requests import Request
 from starlette.responses import JSONResponse
 from tortoise import Model
@@ -19,10 +20,10 @@ from fastgenerateapi.cache.cache_decorator import get_all_cache_decorator
 from fastgenerateapi.cache.key_builder import generate_key_builder
 from fastgenerateapi.controller import SearchController, BaseFilter, FilterController
 from fastgenerateapi.data_type.data_type import DEPENDENCIES, PYDANTIC_SCHEMA
-from fastgenerateapi.deps import paginator_deps, filter_params_deps
+from fastgenerateapi.deps import filter_params_deps
 from fastgenerateapi.deps.filter_params_deps import search_params_deps, extra_filter_params_deps
-from fastgenerateapi.schemas_factory import get_all_schema_factory, get_page_schema_factory, get_one_schema_factory, \
-    response_factory
+from fastgenerateapi.pydantic_utils.base_model import PagePydantic
+from fastgenerateapi.schemas_factory import get_all_schema_factory, get_page_schema_factory, response_factory
 from fastgenerateapi.schemas_factory.get_all_schema_factory import get_list_schema_factory, hasattr_get_all_schema
 from fastgenerateapi.settings.all_settings import settings
 
@@ -58,7 +59,11 @@ class GetAllView(BaseView, GetMixin):
     async def get_all(self, search: Optional[str], filters: dict, *args, **kwargs):
         queryset = await self.get_queryset(search=search, filters=filters, *args, **kwargs)
 
-        return await self.pagination_data(queryset=queryset, *args, **kwargs)
+        return await self.get_page_data(
+            queryset=queryset,
+            prefetch_related_fields=self.prefetch_related_fields,
+            *args, **kwargs
+        )
 
     async def get_queryset(self, search: Optional[str], filters: dict, *args, **kwargs) -> QuerySet:
         """
@@ -89,73 +94,99 @@ class GetAllView(BaseView, GetMixin):
         """
         return model
 
-    async def pagination_data(
+    async def get_queryset_data(
             self,
             queryset: QuerySet,
-            paginator=None,
             schema: Type[BaseModel] = None,
-            name: str = "",  # 当使用fields时，需要输入名称用于自动生成schema
-            fields: List[Union[str, tuple]] = None,
-            *args, **kwargs
+            paginator: Optional[PagePydantic] = PagePydantic(),
+            model_handler_list: Optional[List[Callable]] = None,
+            *args, **kwargs,
     ):
-
-        data_list = []
-        if paginator is None or getattr(paginator, settings.app_settings.DETERMINE_WHETHER_PAGE_FIELD) == \
-                settings.app_settings.DETERMINE_PAGE_BOOL_VALUE:
+        """
+        通用分页函数，获取对应的数据，和分页统计
+        :param queryset:
+        :param schema:
+        :param paginator:
+        :param model_handler_list:
+        :param args:
+        :param kwargs:
+        :return:
+        """
+        count = None
+        if paginator.no_page:
             model_list = await queryset.all()
         else:
             count = await queryset.count()
-            current_num = getattr(paginator, settings.app_settings.CURRENT_PAGE_FIELD)
-            page_size = getattr(paginator, settings.app_settings.PAGE_SIZE_FIELD)
-            queryset = queryset.offset(cast(int, (current_num - 1) * page_size))
-            model_list = await queryset.limit(page_size)
+            queryset = queryset.offset(cast(int, (paginator.page - 1) * paginator.page_size))
+            model_list = await queryset.limit(paginator.page_size)
 
+        data_list = []
         for model in model_list:
+            await self.setattr_model(model,*args, **kwargs)
+            if model_handler_list:
+                for model_handler in model_handler_list:
+                    if is_async_callable(model_handler):
+                        model = await model_handler(model, paginator=paginator,*args, **kwargs)
+                    else:
+                        model = model_handler(model, paginator=paginator,*args, **kwargs)
+            if schema:
+                data_list.append(schema.model_validate(model))
+            else:
+                model = await self.set_get_model(model, paginator=paginator,*args, **kwargs)
+                model = await self.set_get_all_model(model, paginator=paginator, *args, **kwargs)
+                data_list.append(self.get_all_schema.model_validate(model))
 
-            await self.setattr_model(model, prefetch_related_fields=self.prefetch_related_fields, *args, **kwargs)
+        return data_list, count
 
-            # await self.setattr_model_rpc(self.rpc_class, model, self.rpc_param)
-            model = await self.set_get_model(model, *args, **kwargs)
-            model = await self.set_get_all_model(model, *args, **kwargs)
+    def get_page_schema_func(self, data_list, count = None, schema: Type[BaseModel] = None, paginator: Optional[PagePydantic] = None, *args, **kwargs):
+        """
+        返回列表结果
+        :param data_list:
+        :param count:
+        :param schema: 当使用自定义列表时使用，默认列表的get_all_schema
+        :param paginator:
+        :param args:
+        :param kwargs: 自定义列表时，传schema或fields
+        :return:
+        """
+        if paginator.no_page:
+            page_schema = get_list_schema_factory(schema) if schema else self.get_all_list_schema
+        else:
+            page_schema = get_page_schema_factory(schema) if schema else self.get_all_page_schema
 
-            if schema:
-                data_list.append(schema.from_orm(model))
-            elif fields:
-                data_list.append(await self.getattr_model(model=model, fields=fields))
-            else:
-                data_list.append(self.get_all_schema.from_orm(model))
-
-        if paginator is None or getattr(paginator, settings.app_settings.DETERMINE_WHETHER_PAGE_FIELD) == \
-                settings.app_settings.DETERMINE_PAGE_BOOL_VALUE:
-            if schema or fields:
-                return get_list_schema_factory(schema, name)(**{settings.app_settings.LIST_RESPONSE_FIELD: data_list})
-            return self.get_list_schema(**{settings.app_settings.LIST_RESPONSE_FIELD: data_list})
-        if schema or fields:
-            return get_page_schema_factory(schema, name)(**{
-                settings.app_settings.CURRENT_PAGE_FIELD: current_num,
-                settings.app_settings.PAGE_SIZE_FIELD: page_size,
-                settings.app_settings.TOTAL_SIZE_FIELD: count,
+        return page_schema(
+            **paginator.model_dump(by_alias=True),
+            **{
                 settings.app_settings.LIST_RESPONSE_FIELD: data_list,
-            })
-        return self.get_page_schema(**{
-            settings.app_settings.CURRENT_PAGE_FIELD: current_num,
-            settings.app_settings.PAGE_SIZE_FIELD: page_size,
-            settings.app_settings.TOTAL_SIZE_FIELD: count,
-            settings.app_settings.LIST_RESPONSE_FIELD: data_list,
-        })
+                settings.app_settings.TOTAL_SIZE_FIELD: count,
+            }
+        )
 
-    def get_page_list(self, page_result: BaseModel):
-        return getattr(page_result, settings.app_settings.LIST_RESPONSE_FIELD, [])
+    async def get_page_data(
+        self,
+        queryset: QuerySet,
+        *args, **kwargs,
+    ):
+        """
+        通用分页，获取序列化后的值
+        :param queryset:
+        :param args:
+        :param kwargs: 其他参数 schema, paginator, prefetch_related_fields
+        :return:
+        """
+        data_list, count = await self.get_queryset_data(queryset=queryset,*args, **kwargs)
+        res = self.get_page_schema_func(data_list, count, *args, **kwargs)
+        return res
 
     def _get_all_decorator(self, *args: Any, **kwargs: Any) -> DecoratedCallable:
         @get_all_cache_decorator(cache(expire=settings.app_settings.CACHE_GET_ALL_SECONDS, coder=JsonCoder,
                                        key_builder=generate_key_builder))
         async def route(
                 request: Request,
-                paginator=Depends(paginator_deps()),
+                paginator: PagePydantic = Depends(),
                 search: Optional[str] = Depends(search_params_deps(self.search_fields)),
-                filters: dict = Depends(filter_params_deps(model_class=self.model_class, fields=self.filter_fields,
-                                                           schema=self.filter_schema)),
+                filters: dict = Depends(filter_params_deps(
+                    model_class=self.model_class, fields=self.filter_fields, schema=self.filter_schema)),
                 extra_filters: dict = Depends(extra_filter_params_deps(schema=self.extra_filter_schema)),
                 token: Optional[str] = Depends(OAuth2PasswordBearer(tokenUrl="token", auto_error=False)),
         ) -> JSONResponse:
@@ -187,20 +218,14 @@ class GetAllView(BaseView, GetMixin):
         if not self.get_all_schema:
             get_all_schema_include = []
             if self.prefetch_related_fields:
-                for key, value in self.prefetch_related_fields.items():
-                    if value and type(value) in [list, tuple, set]:
-                        for val in value:
-                            val_str = val
-                            if type(val) in [list, tuple, set]:
-                                val_str = val[0]
-                            get_all_schema_include.append(key + "__" + val_str)
+                get_all_schema_include = self._get_extra_related_schema()
             if hasattr_get_all_schema(self.model_class) or get_all_schema_include:
                 self.get_all_schema = get_all_schema_factory(self.model_class, extra_include=get_all_schema_include)
             else:
                 self.get_all_schema = self.get_response_schema()
-        self.get_page_schema = get_page_schema_factory(self.get_all_schema)
-        self.get_list_schema = get_list_schema_factory(self.get_all_schema)
-        self.get_all_response_schema_factory = response_factory(self.get_page_schema, name="GetPage")
+        self.get_all_page_schema = get_page_schema_factory(self.get_all_schema)
+        self.get_all_list_schema = get_list_schema_factory(self.get_all_schema)
+        self.get_all_response_schema_factory = response_factory(self.get_all_page_schema, name="GetPage")
         if not self.get_all_summary:
             doc = self.get_all.__doc__
             self.get_all_summary = doc.strip().split("\n")[0] if doc else "Get All"

{fastgenerateapi-1.2.13 → fastgenerateapi-1.2.15}/fastgenerateapi/api_view/get_relation_view.py

@@ -14,7 +14,9 @@ from tortoise.queryset import QuerySet
 from fastgenerateapi.api_view.base_view import BaseView
 from fastgenerateapi.controller import SearchController, BaseFilter, FilterController
 from fastgenerateapi.data_type.data_type import DEPENDENCIES
-from fastgenerateapi.deps import paginator_deps, filter_params_deps
+from fastgenerateapi.deps import filter_params_deps
+from fastgenerateapi.deps.filter_params_deps import search_params_deps
+from fastgenerateapi.pydantic_utils.base_model import PagePydantic
 from fastgenerateapi.schemas_factory import get_page_schema_factory, response_factory
 from fastgenerateapi.schemas_factory.get_all_schema_factory import get_list_schema_factory
 from fastgenerateapi.schemas_factory.get_relation_schema_factory import get_relation_schema_factory
@@ -54,13 +56,13 @@ class GetRelationView(BaseView):
     relation_order_by_fields: 多对多关联表排序对应字段
     """
 
-    async def get_relation(self, pk: str, search: str, filters: dict, relation_filters: dict, *args, **kwargs):
+    async def get_relation(self, pk: str, search: Optional[str], filters: dict, relation_filters: dict, *args, **kwargs):
         relation_queryset = await self.get_relation_queryset(filters=relation_filters, *args, **kwargs)
         id_list = relation_queryset.filter(Q(**{self.path_id_name: pk})).values_list(self.relation_id_name, flat=True)
 
         queryset = await self.get_queryset(search=search, filters=filters, *args, **kwargs)
 
-        return await self.pagination_data(queryset=queryset, id_list=id_list, *args, **kwargs)
+        return await self.get_tree_data(queryset=queryset, id_list=id_list, *args, **kwargs)
 
     async def get_relation_queryset(self, filters: dict, *args, **kwargs) -> QuerySet:
         """
@@ -104,61 +106,52 @@ class GetRelationView(BaseView):
         """
         return model
 
-    async def pagination_data(
+    async def get_tree_data(
             self,
             queryset: QuerySet,
             id_list,
-            paginator,
+            paginator: Optional[PagePydantic] = PagePydantic(),
             fields: List[Union[str, tuple]] = None,
             *args, **kwargs
     ) -> Union[dict, str, None, BaseModel]:
 
         data_list = []
-        if getattr(paginator, settings.app_settings.DETERMINE_WHETHER_PAGE_FIELD) == settings.app_settings.DETERMINE_PAGE_BOOL_VALUE:
+        if paginator.no_page:
             model_list = await queryset.filter(id__in=id_list).all()
         else:
-            current_num = getattr(paginator, settings.app_settings.CURRENT_PAGE_FIELD)
-            page_size = getattr(paginator, settings.app_settings.PAGE_SIZE_FIELD)
             if self.relation_order_by_fields:
-                id_list = id_list[cast(int, (current_num - 1) * page_size): page_size]
+                id_list = id_list[cast(int, (paginator.page - 1) * paginator.page_size): paginator.page_size]
             queryset = queryset.filter(id__in=id_list)
             count = await queryset.count()
             if self.relation_order_by_fields:
                 model_list = await queryset
             else:
-                queryset = queryset.offset(cast(int, (current_num - 1) * page_size))
-                model_list = await queryset.limit(page_size)
+                queryset = queryset.offset(cast(int, (paginator.page - 1) * paginator.page_size))
+                model_list = await queryset.limit(paginator.page_size)
 
         for model in model_list:
-
             await self.setattr_model(model, prefetch_related_fields=self.prefetch_related_fields, *args, **kwargs)
-
-            # await self.setattr_model_rpc(self.rpc_class, model, self.rpc_param)
             await self.set_get_relation_model(model)
+            data_list.append(self.get_relation_schema.model_validate(model))
 
-            if fields:
-                data_list.append(await self.getattr_model(model=model, fields=fields))
-            else:
-                data_list.append(self.get_relation_schema.from_orm(model))
-
-        if getattr(paginator, settings.app_settings.DETERMINE_WHETHER_PAGE_FIELD) == settings.app_settings.DETERMINE_PAGE_BOOL_VALUE:
+        if paginator.no_page:
             return self.get_relation_list_schema(**{
                 settings.app_settings.LIST_RESPONSE_FIELD: data_list,
             })
-
-        return self.get_relation_page_schema(**{
-            settings.app_settings.CURRENT_PAGE_FIELD: current_num,
-            settings.app_settings.PAGE_SIZE_FIELD: page_size,
-            settings.app_settings.TOTAL_SIZE_FIELD: count,
-            settings.app_settings.LIST_RESPONSE_FIELD: data_list,
-        })
+        return self.get_relation_page_schema(
+            **paginator.model_dump(by_alias=True),
+            **{
+                settings.app_settings.TOTAL_SIZE_FIELD: count,
+                settings.app_settings.LIST_RESPONSE_FIELD: data_list,
+            }
+        )
 
     def _get_relation_decorator(self, *args: Any, **kwargs: Any) -> DecoratedCallable:
         async def route(
                 pk: str,
                 request: Request,
-                paginator=Depends(paginator_deps()),
-                search: str = Query(default="", description="搜索"),
+                paginator: PagePydantic = Depends(),
+                search: Optional[str] = Depends(search_params_deps(self.search_fields)),
                 filters: dict = Depends(filter_params_deps(model_class=self.model_class, fields=self.filter_fields)),
                 relation_filters: dict = Depends(
                     filter_params_deps(model_class=self.relation_model_class, fields=self.relation_filter_fields)),

{fastgenerateapi-1.2.13 → fastgenerateapi-1.2.15}/fastgenerateapi/api_view/get_tree_view.py

@@ -23,7 +23,7 @@ from fastgenerateapi.api_view.base_view import BaseView
 from fastgenerateapi.api_view.mixin.get_mixin import GetMixin
 from fastgenerateapi.controller import SearchController, BaseFilter, FilterController
 from fastgenerateapi.data_type.data_type import DEPENDENCIES
-from fastgenerateapi.deps import paginator_deps, filter_params_deps
+from fastgenerateapi.deps import filter_params_deps
 from fastgenerateapi.deps.tree_params_deps import tree_params_deps
 from fastgenerateapi.schemas_factory import get_one_schema_factory, response_factory
 from fastgenerateapi.schemas_factory.get_tree_schema_factory import get_tree_schema_factory

{fastgenerateapi-1.2.13 → fastgenerateapi-1.2.15}/fastgenerateapi/api_view/mixin/dbmodel_mixin.py

@@ -116,3 +116,30 @@ class DBModelMixin:
         except:
             return model_class
 
+    # ############################### 枚举相关方法 ###############################
+    @classmethod
+    def get_enum_index_by_model(cls, value, model_class, filed):
+        """
+        查找枚举的返回值
+        :param value:
+        :param model_class:
+        :param filed:
+        :return: 找不到返回-1
+        """
+        model_field_info = model_class._meta.fields_map[filed]
+
+        return cls.get_enum_index(value, model_field_info.enum_list, model_field_info.start_num)
+
+    @classmethod
+    def get_enum_index(cls, value, enum_list: List[any], start_num=0) -> int:
+        """
+        查找枚举的返回值
+        :param value: 枚举值
+        :param enum_list: 枚举列表
+        :param start_num:
+        :return: 找不到返回-1
+        """
+        try:
+            return start_num + enum_list.index(value)
+        except Exception as e:
+            return -1

{fastgenerateapi-1.2.13 → fastgenerateapi-1.2.15}/fastgenerateapi/api_view/mixin/response_mixin.py

@@ -5,7 +5,6 @@ from urllib.parse import quote
 
 from fastapi import HTTPException
 from fastapi.encoders import jsonable_encoder
-from pydantic import BaseModel
 
 from fastgenerateapi.settings.all_settings import settings
 from starlette.background import BackgroundTask
@@ -93,7 +92,7 @@ class ResponseMixin:
     @staticmethod
     def stream(
             bytes_io: BytesIO,
-            file_name: Optional[str] = None,
+            filename: Optional[str] = None,
             media_type: Optional[str] = None,
             is_xlsx: Optional[bool] = None,
             is_docx: Optional[bool] = None,
@@ -102,7 +101,7 @@ class ResponseMixin:
         """
 
         :param bytes_io: io.BytesIO()
-        :param file_name: 文件名称
+        :param filename: 文件名称
         :param media_type: 优先度大于其他参数
         :param is_xlsx: 自动设置media_type
         :param is_docx: 自动设置media_type
@@ -118,8 +117,8 @@ class ResponseMixin:
             elif is_pdf:
                 media_type = "application/pdf"
         headers = {}
-        if file_name:
-            headers["Content-Disposition"] = f"attachment; filename={quote(file_name, safe='/:?=&')}"
+        if filename:
+            headers["Content-Disposition"] = f"attachment; filename={quote(filename, safe='/:?=&')}"
         return StreamingResponse(
             bytes_io,
             media_type= media_type,

fastgenerateapi-1.2.15/fastgenerateapi/api_view/mixin/tool_mixin.py

@@ -0,0 +1,49 @@
+from typing import Type, Optional, Dict, List
+
+from pydantic.fields import FieldInfo
+
+from fastgenerateapi.data_type.data_type import T
+
+class ToolMixin:
+
+    @staticmethod
+    def reserve_dict(data: dict) -> dict:
+        """
+        字典key,value互转
+        """
+        result = {}
+        for key, val in data.items():
+            result[val] = key
+        return result
+
+    @staticmethod
+    def get_schema_alise_to_name(schema: Optional[Type[T]]) -> Dict[str, str]:
+        """
+        返回 alias 对 name 的字典
+        :param schema:
+        :return:
+        """
+        alias_dict = {}
+        if schema and hasattr(schema, "model_fields"):
+            for field, info in schema.model_fields.items():
+                alias_dict[info.alias or field] = field
+
+        return alias_dict
+
+    @staticmethod
+    def get_schema_alise_to_field_info(schema: Optional[Type[T]]) -> Dict[str, FieldInfo]:
+        """
+        返回 alias 对 FieldInfo 的字典
+        :param schema:
+        :return:
+        """
+        alias_dict = {}
+        if schema and hasattr(schema, "model_fields"):
+            for field, info in schema.model_fields.items():
+                if info.alias:
+                    alias_dict[info.alias] = info
+                alias_dict[field] = info
+
+        return alias_dict
+
+