fastgenerateapi 1.2.10__tar.gz → 1.2.12__tar.gz

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/PKG-INFO

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

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/fastgenerateapi/__version__.py

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

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/fastgenerateapi/api_view/base_view.py

@@ -220,7 +220,16 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
         :return:
         """
         if not self.response_schema:
-            self.response_schema = get_one_schema_factory(model_class=self.model_class)
+            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)
+            self.response_schema = get_one_schema_factory(self.model_class, extra_include=get_one_schema_include)
 
         return self.response_schema
 

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/fastgenerateapi/api_view/get_all_view.py

@@ -152,9 +152,10 @@ class GetAllView(BaseView, GetMixin):
                                        key_builder=generate_key_builder))
         async def route(
                 request: Request,
-                paginator = Depends(paginator_deps()),
+                paginator=Depends(paginator_deps()),
                 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:
@@ -193,7 +194,10 @@ class GetAllView(BaseView, GetMixin):
                             if type(val) in [list, tuple, set]:
                                 val_str = val[0]
                             get_all_schema_include.append(key + "__" + val_str)
-            self.get_all_schema = get_all_schema_factory(self.model_class, extra_include=get_all_schema_include)
+            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")

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/fastgenerateapi/api_view/get_one_view.py

@@ -75,19 +75,8 @@ class GetOneView(BaseView, GetMixin):
         if func_type != inspect._empty and func_type is not None:
             self.get_one_schema = func_type
         if not self.get_one_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)
-            self.get_one_schema = get_one_schema_factory(
-                model_class=self.model_class,
-                extra_include=get_one_schema_include
-            )
+            self.get_one_schema = self.get_response_schema()
+
         self.get_one_response_schema_factory = response_factory(self.get_one_schema, name="GetOne")
         if not self.get_one_summary:
             doc = self.get_one.__doc__

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/fastgenerateapi/api_view/update_view.py

@@ -59,8 +59,8 @@ class UpdateView(BaseView, SaveMixin):
     async def set_update_model(self, model: Model, data_dict: dict, *args, **kwargs) -> Model:
         """
         在数据模型校验前后修改值:
-        - 【不常使用】：这里修改将不做唯一字段校验
-        - 可用于全局修改
+        - 这里修改将不做唯一字段校验
+        - 可用于例如租户id等全局修改，或者字段变更记录等
         data_dict.update({
             "user_id": request.user.id,
         })

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/fastgenerateapi/schemas_factory/common_function.py

@@ -1,13 +1,14 @@
 import time
 from datetime import datetime
-from typing import Type, Optional, Union, List
+from typing import Type, Optional, Union, List, Callable
 
+from fastapi import HTTPException
 from pydantic import field_validator, model_validator
 from pydantic.fields import FieldInfo
 from tortoise import Model
 
 from fastgenerateapi.api_view.mixin.dbmodel_mixin import DBModelMixin
-from fastgenerateapi.pydantic_utils.base_model import alias_generator
+from fastgenerateapi.pydantic_utils.base_model import alias_generator, BaseModel
 from fastgenerateapi.settings.all_settings import settings
 
 
@@ -77,11 +78,16 @@ def get_field_info_from_model_class(model_class: Type[Model], field: str, descri
             return Optional[str], FieldInfo(default=None, description=f"{field}")
         return get_field_info(value, description=description)
 
-    field_info = model_class._meta.fields_map.get(field.split("__", maxsplit=1)[0])
+    split_left_field = field.split("__", maxsplit=1)[0]
+    field_info = model_class._meta.fields_map.get(split_left_field)
     if field_info:
         description += field_info.description or ""
+    elif split_left_field.endswith("_id"):
+        field_info = model_class._meta.fields_map.get(split_left_field.removesuffix("_id"))
+        if field_info:
+            description += field_info.description or ""
 
-    model_class = DBModelMixin._get_foreign_key_relation_class(model_class, field.split("__", maxsplit=1)[0])
+    model_class = DBModelMixin._get_foreign_key_relation_class(model_class, split_left_field)
 
     return get_field_info_from_model_class(model_class, field.split("__", maxsplit=1)[1], description)
 
@@ -103,7 +109,7 @@ def get_dict_from_pydanticmeta(model_class: Type[Model], data: Union[list, tuple
             if len(field) == 2:
                 if isinstance(field[1], str):
                     key_field = field[1]
-                if isinstance(field[2], FieldInfo):
+                elif isinstance(field[1], FieldInfo):
                     field_info = field[1]
                 else:
                     field_type = field[1]
@@ -160,6 +166,35 @@ def get_validate_dict_from_fields(fields_info: dict) -> dict:
     return validator_dict
 
 
+class FieldValidateInfo(BaseModel):
+    name: str
+    is_required: bool
+    description: str
+    func: Callable
+
+
+def get_field_validate_dict(infos: List[FieldValidateInfo]) -> dict:
+    """
+    字段做校验
+    :param infos:
+    :return:
+    """
+    if not infos:
+        return {}
+
+    def _func(i: FieldValidateInfo):
+        def func(cls, value):
+            is_empty = value is None or value == ''
+            if i.is_required and is_empty:
+                raise HTTPException(status_code=422, detail=i.description+"不能为空")
+            if not is_empty and not i.func(value):
+                raise HTTPException(status_code=422, detail=i.description+"校验不通过")
+            return value
+        return func
+
+    return {"check_"+info.name: field_validator(info.name)(_func(info)) for info in infos}
+
+
 def get_model_validate_text_to_list(fields: Optional[List[str]]) -> dict:
     """
     详情列表用于返回

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/fastgenerateapi/schemas_factory/common_schema_factory.py

@@ -31,18 +31,18 @@ def common_schema_factory(
         exclude_fields.update(["id", "created_at", "modified_at", "updated_at"])
     if include:
         include_fields_dict = get_dict_from_pydanticmeta(model_class, include)
-        all_fields_info.update(include_fields_dict)
+        all_fields_info = {**include_fields_dict, **all_fields_info}
         include_fields.update(include_fields_dict.keys())
     else:
         if hasattr(model_class, "PydanticMeta"):
             if pydantic_meta_include:
                 include_fields_dict = get_dict_from_pydanticmeta(model_class, pydantic_meta_include)
-                all_fields_info.update(include_fields_dict)
+                all_fields_info = {**include_fields_dict, **all_fields_info}
                 include_fields.update(include_fields_dict.keys())
             else:
                 if hasattr(model_class.PydanticMeta, "include"):
                     include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.include)
-                    all_fields_info.update(include_fields_dict)
+                    all_fields_info = {**include_fields_dict, **all_fields_info}
                     include_fields.update(include_fields_dict.keys())
                 else:
                     include_fields.update(all_fields_info.keys())
@@ -53,7 +53,7 @@ def common_schema_factory(
 
     if extra_include:
         include_fields_dict = get_dict_from_pydanticmeta(model_class, extra_include)
-        all_fields_info.update(include_fields_dict)
+        all_fields_info = {**include_fields_dict, **all_fields_info}
         include_fields.update(include_fields_dict.keys())
     if exclude:
         exclude_fields.update(exclude)

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/fastgenerateapi/schemas_factory/create_schema_factory.py

@@ -8,7 +8,7 @@ from tortoise import Model
 
 from fastgenerateapi.data_type.data_type import T
 from fastgenerateapi.schemas_factory.common_function import get_dict_from_model_fields, get_dict_from_pydanticmeta, \
-    get_validate_dict_from_fields, get_model_validate_list_to_text
+    get_validate_dict_from_fields, get_model_validate_list_to_text, FieldValidateInfo, get_field_validate_dict
 
 
 def create_schema_factory(
@@ -23,6 +23,8 @@ def create_schema_factory(
         pydantic_meta_save_exclude: Optional[bool] = True,
         pydantic_meta_create_include: Optional[bool] = True,
         pydantic_meta_create_exclude: Optional[bool] = True,
+        pydantic_meta_save_validate: Optional[bool] = True,
+        pydantic_meta_create_validate: Optional[bool] = True,
         pydantic_meta_text_to_list: Optional[bool] = True,
         name: Optional[str] = None
 ) -> Type[T]:
@@ -36,6 +38,8 @@ def create_schema_factory(
     - save_exclude: 增改通用，指定排除字段
     - create_include: 增使用，额外添加字段
     - create_exclude: 增使用，指定排除字段
+    - save_validate: 增改通用，指定字段做校验
+    - create_validate: 增使用，指定字段做校验
 
     逻辑顺序：合并所有include和exclude，排除include下包含的exclude字段
 
@@ -65,14 +69,17 @@ def create_schema_factory(
                 ("item_id_list", List[str], FieldInfo(description="多对多关联id列表")),
             ]
             save_exclude = ["ignore_field"]
+            save_validate = [("phone", phone_validate), ("id_card", id_card_validate)]
             create_include = ["create_user"]
             create_exclude = []
+            create_validate = []
     """
     all_fields_info = get_dict_from_model_fields(model_class)
 
     include_fields = set()
     exclude_fields = set()
     text_to_list_fields = set()
+    validate_field_info = []
     if include:
         include_fields_dict = get_dict_from_pydanticmeta(model_class, include)
         all_fields_info.update(include_fields_dict)
@@ -104,6 +111,24 @@ def create_schema_factory(
                 exclude_fields.update(model_class.PydanticMeta.save_exclude)
             if pydantic_meta_create_exclude and hasattr(model_class.PydanticMeta, "create_exclude"):
                 exclude_fields.update(model_class.PydanticMeta.create_exclude)
+            if pydantic_meta_save_validate and hasattr(model_class.PydanticMeta, "save_validate"):
+                for validate in model_class.PydanticMeta.save_validate:
+                    file_type, file_info = all_fields_info.get(validate[0])
+                    validate_field_info.append(FieldValidateInfo(
+                        name=validate[0],
+                        is_required=file_info.is_required(),
+                        description=file_info.description,
+                        func=validate[1],
+                    ))
+            if pydantic_meta_create_validate and hasattr(model_class.PydanticMeta, "create_validate"):
+                for validate in model_class.PydanticMeta.create_validate:
+                    file_type, file_info = all_fields_info.get(validate[0])
+                    validate_field_info.append(FieldValidateInfo(
+                        name=validate[0],
+                        is_required=file_info.is_required(),
+                        description=file_info.description,
+                        func=validate[1],
+                    ))
             if pydantic_meta_text_to_list and hasattr(model_class.PydanticMeta, "text_to_list"):
                 text_to_list_fields = getattr(model_class.PydanticMeta, "text_to_list")
                 for field in text_to_list_fields:
@@ -136,12 +161,13 @@ def create_schema_factory(
     schema_name = name if name else model_class.__name__ + "CreateSchema"
     schema_field_dict = {field: all_fields_info[field] for field in all_fields}
     validators_dict = get_validate_dict_from_fields(schema_field_dict)
+    field_validators = get_field_validate_dict(validate_field_info)
     text_to_list_validators_dict = get_model_validate_list_to_text(text_to_list_fields)
     schema: Type[T] = create_model(
         schema_name,
         **schema_field_dict,
         __config__=model_config,
-        __validators__={**validators_dict, **text_to_list_validators_dict},
+        __validators__={**validators_dict, **field_validators, **text_to_list_validators_dict},
     )
     return schema
 

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/fastgenerateapi/schemas_factory/get_all_schema_factory.py

@@ -91,7 +91,7 @@ def get_all_schema_factory(
     text_to_list_fields = set()
     if include:
         include_fields_dict = get_dict_from_pydanticmeta(model_class, include)
-        all_fields_info.update(include_fields_dict)
+        all_fields_info = {**include_fields_dict, **all_fields_info}
         include_fields.update(include_fields_dict.keys())
     else:
         if hasattr(model_class, "PydanticMeta"):
@@ -131,29 +131,29 @@ def get_all_schema_factory(
         else:
             include_fields.update(all_fields_info.keys())
 
-    if extra_include:
-        include_fields_dict = get_dict_from_pydanticmeta(model_class, extra_include)
-        all_fields_info.update(include_fields_dict)
-        include_fields.update(include_fields_dict.keys())
-    if exclude:
-        exclude_fields.update(exclude)
-
-    all_fields = include_fields.difference(exclude_fields)
-    if settings.app_settings.GET_EXCLUDE_ACTIVE_VALUE:
-        try:
-            all_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
-        except Exception:
-            ...
-
-    schema_name = name if name else model_class.__name__ + "GetAllSchema"
-    text_to_list_validators_dict = get_model_validate_text_to_list(text_to_list_fields)
-    schema: Type[T] = create_model(
-        schema_name,
-        **{field: all_fields_info[field] for field in all_fields},
-        __config__=model_config,
-        __validators__={**text_to_list_validators_dict},
-    )
-    return schema
+        if extra_include:
+            include_fields_dict = get_dict_from_pydanticmeta(model_class, extra_include)
+            all_fields_info.update(include_fields_dict)
+            include_fields.update(include_fields_dict.keys())
+        if exclude:
+            exclude_fields.update(exclude)
+
+        all_fields = include_fields.difference(exclude_fields)
+        if settings.app_settings.GET_EXCLUDE_ACTIVE_VALUE:
+            try:
+                all_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
+            except Exception:
+                ...
+
+        schema_name = name if name else model_class.__name__ + "GetAllSchema"
+        text_to_list_validators_dict = get_model_validate_text_to_list(text_to_list_fields)
+        schema: Type[T] = create_model(
+            schema_name,
+            **{field: all_fields_info[field] for field in all_fields},
+            __config__=model_config,
+            __validators__={**text_to_list_validators_dict},
+        )
+        return schema
 
 
 def get_list_schema_factory(schema_cls: Type[T] = None, response_field: Optional[str] = None, name: str = "") -> Type[T]:

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/fastgenerateapi/schemas_factory/get_one_schema_factory.py

@@ -12,6 +12,13 @@ from fastgenerateapi.pydantic_utils.base_model import model_config
 from fastgenerateapi.schemas_factory.common_function import get_dict_from_model_fields, get_dict_from_pydanticmeta, \
     get_model_validate_text_to_list
 
+def hasattr_get_one_schema(model_class: Type[Model],):
+    if not hasattr(model_class, "PydanticMeta"):
+        return False
+    if hasattr(model_class.PydanticMeta, "get_one_include") or hasattr(model_class.PydanticMeta, "get_one_exclude"):
+        return True
+    return False
+
 
 def get_one_schema_factory(
         model_class: Type[Model],
@@ -82,7 +89,7 @@ def get_one_schema_factory(
     text_to_list_fields = set()
     if include:
         include_fields_dict = get_dict_from_pydanticmeta(model_class, include)
-        all_fields_info.update(include_fields_dict)
+        all_fields_info = {**include_fields_dict, **all_fields_info}
         include_fields.update(include_fields_dict.keys())
     else:
         if hasattr(model_class, "PydanticMeta"):
@@ -122,30 +129,30 @@ def get_one_schema_factory(
         else:
             include_fields.update(all_fields_info.keys())
 
-    if extra_include:
-        include_fields_dict = get_dict_from_pydanticmeta(model_class, extra_include)
-        all_fields_info.update(include_fields_dict)
-        include_fields.update(include_fields_dict.keys())
-    if exclude:
-        exclude_fields.update(exclude)
-
-    all_fields = include_fields.difference(exclude_fields)
-
-    if settings.app_settings.GET_EXCLUDE_ACTIVE_VALUE:
-        try:
-            all_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
-        except Exception:
-            ...
-
-    schema_name = name if name else model_class.__name__ + "GetOneSchema"
-    text_to_list_validators_dict = get_model_validate_text_to_list(text_to_list_fields)
-    schema: Type[T] = create_model(
-        schema_name,
-        **{field: all_fields_info[field] for field in all_fields},
-        __config__=model_config,
-        __validators__={**text_to_list_validators_dict},
-    )
-    return schema
+        if extra_include:
+            include_fields_dict = get_dict_from_pydanticmeta(model_class, extra_include)
+            all_fields_info.update(include_fields_dict)
+            include_fields.update(include_fields_dict.keys())
+        if exclude:
+            exclude_fields.update(exclude)
+
+        all_fields = include_fields.difference(exclude_fields)
+
+        if settings.app_settings.GET_EXCLUDE_ACTIVE_VALUE:
+            try:
+                all_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
+            except Exception:
+                ...
+
+        schema_name = name if name else model_class.__name__ + "GetOneSchema"
+        text_to_list_validators_dict = get_model_validate_text_to_list(text_to_list_fields)
+        schema: Type[T] = create_model(
+            schema_name,
+            **{field: all_fields_info[field] for field in all_fields},
+            __config__=model_config,
+            __validators__={**text_to_list_validators_dict},
+        )
+        return schema
 
 
 

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/fastgenerateapi/schemas_factory/get_relation_schema_factory.py

@@ -65,31 +65,31 @@ def get_relation_schema_factory(
         else:
             include_fields.update(all_fields_info.keys())
 
-    if extra_include:
-        include_fields_dict = get_dict_from_pydanticmeta(model_class, extra_include)
-        all_fields_info.update(include_fields_dict)
-        include_fields.update(include_fields_dict.keys())
-    if exclude:
-        exclude_fields.update(exclude)
-
-    all_fields = include_fields.difference(exclude_fields)
-
-    if settings.app_settings.GET_EXCLUDE_ACTIVE_VALUE:
-        try:
-            all_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
-        except Exception:
-            ...
-
-    schema_name = name if name else model_class.__name__ + "GetRelationSchema"
-    text_to_list_validators_dict = get_model_validate_text_to_list(text_to_list_fields)
-    schema: Type[T] = create_model(
-        schema_name,
-        **{field: all_fields_info[field] for field in all_fields},
-        __config__=model_config,
-        __validators__={**text_to_list_validators_dict},
-    )
-
-    return schema
+        if extra_include:
+            include_fields_dict = get_dict_from_pydanticmeta(model_class, extra_include)
+            all_fields_info.update(include_fields_dict)
+            include_fields.update(include_fields_dict.keys())
+        if exclude:
+            exclude_fields.update(exclude)
+
+        all_fields = include_fields.difference(exclude_fields)
+
+        if settings.app_settings.GET_EXCLUDE_ACTIVE_VALUE:
+            try:
+                all_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
+            except Exception:
+                ...
+
+        schema_name = name if name else model_class.__name__ + "GetRelationSchema"
+        text_to_list_validators_dict = get_model_validate_text_to_list(text_to_list_fields)
+        schema: Type[T] = create_model(
+            schema_name,
+            **{field: all_fields_info[field] for field in all_fields},
+            __config__=model_config,
+            __validators__={**text_to_list_validators_dict},
+        )
+
+        return schema
 
 
 

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/fastgenerateapi/schemas_factory/get_tree_schema_factory.py

@@ -107,82 +107,5 @@ def get_tree_schema_factory(
     return schema
 
 
-# def get_tree_schema_factory(
-#         model_class: Type[Model],
-#         include: Union[list, tuple, set] = None,
-#         extra_include: Union[list, tuple, set] = None,
-#         exclude: Union[list, tuple, set] = None,
-# ) -> Optional[Type[T]]:
-#     """
-#     Is used to create a GetTreeSchema
-#     """
-#     def get_tree_schema(schema_cls: Optional[Type[T]] = None):
-#         all_fields_info: dict = get_dict_from_model_fields(model_class)
-#
-#         include_fields = set()
-#         exclude_fields = set()
-#         if hasattr(model_class, "PydanticMeta"):
-#             if hasattr(model_class.PydanticMeta, "get_tree_include"):
-#                 get_tree_include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.get_tree_include)
-#                 all_fields_info.update(get_tree_include_fields_dict)
-#                 include_fields.update(get_tree_include_fields_dict.keys())
-#             if hasattr(model_class.PydanticMeta, "include"):
-#                 include_fields_dict = get_dict_from_pydanticmeta(model_class, model_class.PydanticMeta.include)
-#                 all_fields_info.update(include_fields_dict)
-#                 include_fields.update(include_fields_dict.keys())
-#             else:
-#                 include_fields.update(all_fields_info.keys())
-#             if hasattr(model_class.PydanticMeta, "get_tree_exclude"):
-#                 exclude_fields.update(model_class.PydanticMeta.get_tree_exclude)
-#             if hasattr(model_class.PydanticMeta, "exclude"):
-#                 exclude_fields.update(model_class.PydanticMeta.exclude)
-#         else:
-#             include_fields.update(all_fields_info.keys())
-#
-#         if include:
-#             include_fields_dict = get_dict_from_pydanticmeta(model_class, include)
-#             all_fields_info.update(include_fields_dict)
-#             include_fields.update(include_fields_dict.keys())
-#         if extra_include:
-#             include_fields_dict = get_dict_from_pydanticmeta(model_class, extra_include)
-#             all_fields_info.update(include_fields_dict)
-#             include_fields.update(include_fields_dict.keys())
-#         if exclude:
-#             exclude_fields.update(exclude)
-#
-#         all_fields = include_fields.difference(exclude_fields)
-#
-#         if schema_cls:
-#             all_fields_info.setdefault(
-#                 settings.app_settings.DEFAULT_TREE_CHILDREN_FIELD,
-#                 (Optional[List[Type[schema_cls]]], FieldInfo(default=None, description="子级目录"))
-#             )
-#         else:
-#             all_fields_info.setdefault(
-#                 settings.app_settings.DEFAULT_TREE_CHILDREN_FIELD,
-#                 (Optional[list], FieldInfo(default=None, description="子级目录"))
-#             )
-#         all_fields.add(settings.app_settings.DEFAULT_TREE_CHILDREN_FIELD)
-#         if settings.app_settings.GET_EXCLUDE_ACTIVE_VALUE:
-#             try:
-#                 all_fields.remove(settings.app_settings.WHETHER_DELETE_FIELD)
-#             except Exception:
-#                 ...
-#
-#         name = model_class.__name__ + "GetTreeSchema"
-#         schema: Type[T] = create_model(
-#             __model_name=name, **{field: all_fields_info[field] for field in all_fields}, __config__=Config)
-#
-#         return schema
-#
-#     tree_schema = get_tree_schema()
-#     return get_tree_schema(tree_schema)
-
-
-
-
-
-
-
 
 

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/fastgenerateapi/schemas_factory/update_schema_factory.py

@@ -10,7 +10,7 @@ from tortoise import Model
 
 from fastgenerateapi.data_type.data_type import T
 from fastgenerateapi.schemas_factory.common_function import get_dict_from_model_fields, get_dict_from_pydanticmeta, \
-    get_validate_dict_from_fields, get_model_validate_list_to_text
+    get_validate_dict_from_fields, get_model_validate_list_to_text, FieldValidateInfo, get_field_validate_dict
 
 
 def update_schema_factory(
@@ -25,6 +25,8 @@ def update_schema_factory(
         pydantic_meta_save_exclude: Optional[bool] = True,
         pydantic_meta_update_include: Optional[bool] = True,
         pydantic_meta_update_exclude: Optional[bool] = True,
+        pydantic_meta_save_validate: Optional[bool] = True,
+        pydantic_meta_update_validate: Optional[bool] = True,
         pydantic_meta_text_to_list: Optional[bool] = True,
         name: Optional[str] = None
 ) -> Type[T]:
@@ -36,8 +38,10 @@ def update_schema_factory(
     - exclude： 增改详情列表通用，指定排除字段
     - save_include: 增改通用，额外添加字段
     - save_exclude: 增改通用，指定排除字段
-    - update_include: 增使用，额外添加字段
-    - update_exclude: 增使用，指定排除字段
+    - update_include: 改使用，额外添加字段
+    - update_exclude: 改使用，指定排除字段
+    - save_validate: 增改通用，指定字段做校验
+    - update_validate: 改使用，指定字段做校验
 
     逻辑顺序：合并所有include和exclude，排除include下包含的exclude字段
 
@@ -67,14 +71,17 @@ def update_schema_factory(
                 ("item_id_list", List[str], FieldInfo(description="多对多关联id列表")),
             ]
             save_exclude = ["ignore_field"]
+            save_validate = [("phone", phone_validate), ("id_card", id_card_validate)]
             update_include = ["update_user"]
             update_exclude = []
+            update_validate = []
     """
     all_fields_info = get_dict_from_model_fields(model_class)
 
     include_fields = set()
     exclude_fields = set()
     text_to_list_fields = set()
+    validate_field_info = []
     if include:
         include_fields_dict = get_dict_from_pydanticmeta(model_class, include)
         all_fields_info.update(include_fields_dict)
@@ -106,6 +113,24 @@ def update_schema_factory(
                 exclude_fields.update(model_class.PydanticMeta.save_exclude)
             if pydantic_meta_update_exclude and hasattr(model_class.PydanticMeta, "update_exclude"):
                 exclude_fields.update(model_class.PydanticMeta.update_exclude)
+            if pydantic_meta_save_validate and hasattr(model_class.PydanticMeta, "save_validate"):
+                for validate in model_class.PydanticMeta.save_validate:
+                    file_type, file_info = all_fields_info.get(validate[0])
+                    validate_field_info.append(FieldValidateInfo(
+                        name=validate[0],
+                        is_required=file_info.is_required(),
+                        description=file_info.description,
+                        func=validate[1],
+                    ))
+            if pydantic_meta_update_validate and hasattr(model_class.PydanticMeta, "update_validate"):
+                for validate in model_class.PydanticMeta.create_validate:
+                    file_type, file_info = all_fields_info.get(validate[0])
+                    validate_field_info.append(FieldValidateInfo(
+                        name=validate[0],
+                        is_required=file_info.is_required(),
+                        description=file_info.description,
+                        func=validate[1],
+                    ))
             if pydantic_meta_text_to_list and hasattr(model_class.PydanticMeta, "text_to_list"):
                 text_to_list_fields = getattr(model_class.PydanticMeta, "text_to_list")
                 for field in text_to_list_fields:
@@ -138,11 +163,12 @@ def update_schema_factory(
     schema_name = name if name else model_class.__name__ + "UpdateSchema"
     schema_field_dict = {field: all_fields_info[field] for field in all_fields}
     validators_dict = get_validate_dict_from_fields(schema_field_dict)
+    field_validators = get_field_validate_dict(validate_field_info)
     text_to_list_validators_dict = get_model_validate_list_to_text(text_to_list_fields)
     schema: Type[T] = create_model(
         schema_name,
         **schema_field_dict,
         __config__=model_config,
-        __validators__={**validators_dict, **text_to_list_validators_dict},
+        __validators__={**validators_dict, **field_validators, **text_to_list_validators_dict},
     )
     return schema

fastgenerateapi-1.2.12/fastgenerateapi/validator/validator.py

@@ -0,0 +1,61 @@
+import re
+from datetime import datetime, date
+from typing import Optional
+
+
+def phone_validate(phone: Optional[str]) -> bool:
+    """
+    手机号码校验
+    :param phone:
+    :return:
+    """
+    if not phone:
+        return False
+    phone_pattern = re.compile(r'^(?:(?:\+|00)86)?1[3-9]\d{9}$')
+
+    return phone_pattern.fullmatch(phone) is not None
+
+
+def id_card_validate(id_card: Optional[str]) -> bool:
+    """
+    身份证号码校验
+    :param id_card:
+    :return:
+    """
+    if not id_card or len(id_card) != 18:
+        return False
+    id_card = id_card.upper()
+    if not id_card[:17].isdigit() or id_card[-1] not in '0123456789X':
+        return False
+    date_of_birth = datetime(
+        year=int(id_card[6:10]),
+        month=int(id_card[10:12]),
+        day=int(id_card[12:14])
+    )
+    current_date = date.today()
+    if date_of_birth > current_date or date_of_birth.year < 1900:
+        return False
+
+    weights = [7, 9, 10, 5, 8, 4, 2, 1, 6, 3, 7, 9, 10, 5, 8, 4, 2]
+    check_code_map = {0: '1', 1: '0', 2: 'X', 3: '9', 4: '8', 5: '7', 6: '6', 7: '5', 8: '4', 9: '3', 10: '2'}
+
+    total = sum(int(id_card[i]) * weights[i] for i in range(17))
+
+    remainder = total % 11
+    expected_check_code = check_code_map[remainder]
+    return id_card[-1] == expected_check_code
+
+
+def email_validate(email: Optional[str]) -> bool:
+    """
+    验证邮箱格式合法性（符合RFC 5322简化标准，覆盖99%+日常/开发场景）
+    :param email: 待校验的邮箱字符串
+    :return: 合法返回True，否则False
+    """
+    if not email:
+        return False
+
+    email_pattern = r'^[a-zA-Z0-9_%+-]+(?:\.[a-zA-Z0-9_%+-]+)*@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$'
+
+    return re.fullmatch(email_pattern, email) is not None
+

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/fastgenerateapi.egg-info/PKG-INFO

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

{fastgenerateapi-1.2.10 → fastgenerateapi-1.2.12}/fastgenerateapi.egg-info/SOURCES.txt

@@ -111,4 +111,6 @@ fastgenerateapi/utils/ramdom_utils.py
 fastgenerateapi/utils/snowflake.py
 fastgenerateapi/utils/str_util.py
 fastgenerateapi/utils/swagger_to_js.py
+fastgenerateapi/validator/__init__.py
+fastgenerateapi/validator/validator.py
 script/__init__.py