fastgenerateapi 0.0.28__py2.py3-none-any.whl → 1.1.6__py2.py3-none-any.whl

fastgenerateapi/api_view/mixin/utils/xlsx_util.py

@@ -0,0 +1,336 @@
+import importlib
+import io
+import operator
+from tempfile import NamedTemporaryFile
+from typing import List, Union, Optional, Dict, Type
+
+import openpyxl
+from fastapi import UploadFile
+from openpyxl.styles import Alignment, PatternFill
+from openpyxl.styles.colors import COLOR_INDEX, Color
+from openpyxl.utils import get_column_letter
+from openpyxl.worksheet.worksheet import Worksheet
+from starlette._utils import is_async_callable
+from starlette.responses import StreamingResponse, JSONResponse, FileResponse
+from tortoise import Model
+from pydantic import ValidationError
+
+from fastgenerateapi import BaseModel, BaseView
+from fastgenerateapi.api_view.mixin.response_mixin import ResponseMixin
+from fastgenerateapi.schemas_factory.common_schema_factory import common_schema_factory
+
+
+class XlsxUtil:
+    default_align = Alignment(
+        horizontal='center',
+        vertical='center',
+        text_rotation=0,
+        wrap_text=True,
+        shrink_to_fit=True,
+        indent=0,
+    )
+    default_fill = PatternFill(
+        start_color=Color(COLOR_INDEX[44]),
+        end_color=Color(COLOR_INDEX[44]),
+        fill_type='solid'
+    )
+
+    @staticmethod
+    def write_headers(sh: Worksheet, headers: List[str]) -> List[int]:
+        """
+        写入第一行信息
+        :return:
+        """
+        col_max_len_list = []
+        sh.row_dimensions[1].height = 26
+        for col, header in enumerate(headers, 1):
+            sh.cell(1, col).value = header
+            sh.cell(1, col).alignment = XlsxUtil.default_align
+            sh.cell(1, col).fill = XlsxUtil.default_fill
+            sh.cell(1, col).alignment = XlsxUtil.default_align
+            col_max_len_list.append(len(header.encode('gb18030')))
+
+        return col_max_len_list
+
+    @staticmethod
+    def write_content(model_list: List[Model]):
+        """
+        填写内容部分
+        :return:
+        """
+        # 跳过标题，从第二行开始写入
+        for row, model in enumerate(model_list, 2):
+            ...
+
+        return
+
+    @staticmethod
+    def adaptive_format(sh: Worksheet, col_max_len_list: List[int], height_num: int):
+        """
+        自适应宽度
+        :return:
+        """
+        # 设置自适应列宽
+        for i, col_max_len in enumerate(col_max_len_list, 1):
+            # 256*字符数得到excel列宽,为了不显得特别紧凑添加两个字符宽度
+            max_width = col_max_len + 4
+            if max_width > 256:
+                max_width = 256
+            sh.column_dimensions[get_column_letter(i)].width = max_width
+        for y in range(2, height_num + 2):
+            sh.row_dimensions[y].height = 18
+
+        return
+
+    async def export_xlsx(
+            self,
+            model_list: List[Model],
+            headers: List[str],
+            fields: List[str],
+            fields_handler: dict,
+            file_save_path: Optional[str] = None,
+            # rpc_param: Union[Dict[str, Dict[str, List[str]]], Type[RPCParam], None] = None,
+            title: str = None,
+    ) -> StreamingResponse:
+        wb = openpyxl.Workbook()
+        col_max_len_list = []
+
+        def write(sh, row, col, value):
+            sh.cell(row, col).value = value
+            sh.cell(row, col).alignment = XlsxUtil.default_align
+            if col_max_len_list[col - 1] < len(str(value).encode('gb18030')):
+                col_max_len_list[col - 1] = len(str(value).encode('gb18030'))
+
+        start_row = 1
+        try:
+            sh = wb.active
+            sh.title = title if title else f'{self.model_class._meta.table_description}'
+
+            col_max_len_list = XlsxUtil.write_headers(sh, headers)
+
+            for row, model in enumerate(model_list, start_row + 1):
+                model = await BaseView.getattr_model(model=model, fields=fields)
+                # model = await self.setattr_model_rpc(self.model_class, model, rpc_param)
+
+                for col, field in enumerate(fields, 1):
+                    info = getattr(model, field, "")
+                    handler = fields_handler.get(field)
+                    if handler and hasattr(handler, "__call__"):
+                        if is_async_callable(handler):
+                            info = await handler(info)
+                        else:
+                            info = handler(info)
+                    write(sh, row, col, info)
+
+            XlsxUtil.adaptive_format(sh, col_max_len_list, len(model_list))
+        finally:
+            if file_save_path:
+                wb.save(file_save_path)
+                return ResponseMixin.success(msg="请求成功")
+            bytes_io = io.BytesIO()
+            wb.save(bytes_io)
+            bytes_io.seek(0)
+
+        return ResponseMixin.stream(bytes_io, is_xlsx=True)
+
+    async def import_xlsx(
+            self,
+            file: UploadFile,
+            headers: List[str],
+            # [
+            #        "name",
+            #       ("is_male", {"男"： True, "女": False} 或者 方法, {"额外字段"： 方法}, ...),
+            # ]
+            # 方法(默认传excel的值)
+            fields: List[Union[str, dict, tuple, list]],
+            combine_fields: Optional[List[Dict[str, any]]] = None,
+            model_class: Optional[Type[Model]] = None,
+            create_schema: Optional[Type[BaseModel]] = None,
+            # storage_path: Union[str, Path],
+            # rpc_param: Union[Dict[str, Dict[str, List[Union[str, tuple]]]], Type[RPCParam]] = None,
+            modules: str = "openpyxl",
+    ) -> JSONResponse:
+        """
+        fields: 方法(默认传excel的值)
+        例如：
+        [
+            "name",    # 传入值是 name 字段的值
+            ("is_male", {"男"： True, "女": False} 或者 方法, {"额外字段"： 方法}, ...),
+            # 值 "男" 获取为bool值，不在字典里为None, 页可以自定义 同步或异步方法 获取值
+        ]
+        """
+        limit_modules = ["openpyxl"]
+        if modules not in limit_modules:
+            return ResponseMixin.error(msg=f"export xlsx modules only import {'、'.join(limit_modules)}")
+
+        if not file:
+            return ResponseMixin.fail(msg=f"请先选择合适的文件")
+
+        if not model_class:
+            model_class = self.model_class
+        if not create_schema:
+            create_schema = common_schema_factory(model_class, name=f"{model_class.__name__}ExcelImportSchema")
+
+        with NamedTemporaryFile() as tmp2:
+            tmp2.write(await file.read())
+            try:
+                wb = importlib.import_module(modules).load_workbook(tmp2, read_only=True, data_only=True)
+            except Exception:
+                return ResponseMixin.error(msg=f"please pip install {modules}")
+
+            try:
+                ws = wb.active
+
+                header_row = ws[1]
+                header_list = []
+                for msg in header_row:
+                    header_list.append(str(msg.value).replace(" ", ''))
+
+                if len(header_list) != len(headers):
+                    return ResponseMixin.fail(message="文件首行长度校验错误")
+
+                if not operator.eq(header_list, headers):
+                    return ResponseMixin.fail(message="文件首行内容校验错误")
+
+                # if ws.max_row < 2:
+                #     return ResponseMixin.fail(msg="导入数据不能为空")
+
+                create_list = []
+                effective_row = 0
+                for row in range(2, ws.max_row + 1):
+                    data = {}
+                    # data_schema = {}
+                    row_data = ws[row]
+                    if await self.excel_row_is_empty(row_data):
+                        continue
+                    effective_row += 1
+                    for col, field_input in enumerate(fields):
+                        if type(field_input) in [str, int]:
+                            data[field_input] = row_data[col].value
+                            # data_schema[field_input] = (type(row_data[col].value), ...)
+
+                        if type(field_input) == tuple or type(field_input) == list:
+                            key = field_input[0]
+                            val = field_input[1]
+                            required_doc = {}
+                            if len(field_input) > 2:
+                                required_doc = field_input[2]
+                                if required_doc == "required":
+                                    required_doc = {"required": True}
+                            if type(val) == dict:
+                                model_val = val.get(row_data[col].value)
+                                if not model_val and required_doc.get("required"):
+                                    return ResponseMixin.fail(
+                                        msg=required_doc.get("error",
+                                                             "") or f"第{row}行{self.get_field_description(key)}不能为空")
+                                data[key] = model_val
+                                # data_schema[key] = (type(model_val), ...)
+                            elif hasattr(val, "__call__"):
+                                if is_async_callable(val):
+                                    model_val = await val(row_data[col].value)
+                                else:
+                                    model_val = val(row_data[col].value)
+                                data[key] = model_val
+                                # data_schema[key] = (type(model_val), ...)
+                            else:
+                                raise NotImplemented
+                        else:
+                            raise NotImplemented
+                    for combine_field in combine_fields:
+                        field = combine_field.get("field", None)
+                        value = combine_field.get("value", None)
+                        function = combine_field.get("function", None)
+                        args = combine_field.get("args", None)
+                        if not field or (not function and not value):
+                            continue
+                        if value:
+                            data[field] = value
+                        else:
+                            if not args:
+                                if is_async_callable(function):
+                                    model_val = await function()
+                                else:
+                                    model_val = function()
+                            else:
+                                args_list = []
+                                for arg in args:
+                                    args_list.append(data.get(arg, ""))
+                                if is_async_callable(function):
+                                    model_val = await function(*args_list)
+                                else:
+                                    model_val = function(*args_list)
+                            data[field] = model_val
+                    try:
+                        create_obj = model_class(**create_schema(**data).dict(exclude_unset=True))
+                    except ValidationError as e:
+                        error_field = e.errors()[0].get('loc')[0]
+                        description = self.get_field_description(error_field)
+                        if not data.get(error_field):
+                            return ResponseMixin.fail(message=f"第{row}行{description}不能为空")
+                        return ResponseMixin.fail(message=f"第{row}行{description}填写错误")
+                    await self.check_unique_field(create_obj, model_class=model_class)
+                    create_list.append(create_obj)
+
+                await model_class.bulk_create(create_list)
+            finally:
+                wb.close()
+            if effective_row == 0:
+                return ResponseMixin.fail(message="导入数据不能为空")
+        return ResponseMixin.success(msg='创建成功')
+
+    @staticmethod
+    async def excel_row_is_empty(row_list) -> bool:
+        is_empty = True
+        for row in row_list:
+            if row.value is not None:
+                return False
+
+        return is_empty
+
+    async def excel_model(
+            self,
+            headers: List[str] = None,
+            model_class: Optional[Model] = None,
+            excel_model_path: Optional[str] = None,
+            modules: str = "openpyxl",
+            title: Optional[str] = None,
+    ) -> Union[FileResponse, StreamingResponse]:
+        if excel_model_path:
+            return FileResponse(
+                path=excel_model_path,
+                filename="导入模板.xlsx",
+                media_type="xlsx",
+            )
+
+        limit_modules = ["openpyxl", "xlsxwriter"]
+        if modules not in limit_modules:
+            return ResponseMixin.error(msg=f"export xlsx modules only import {'、'.join(limit_modules)}")
+        try:
+            wb = importlib.import_module(modules).Workbook()
+        except Exception:
+            return ResponseMixin.error(msg=f"please pip install {modules}")
+        if modules == "openpyxl":
+            def write(sh, row, col, value):
+                sh.cell(row, col).value = value
+
+            start_col = 1
+            start_row = 1
+        else:
+            def write(sh, row, col, value):
+                sh.write(row, col, value)
+
+            start_col = 0
+            start_row = 0
+        try:
+            sh = wb.active
+            sh.title = title if title else f'{model_class._meta.table_description}'
+
+            for col, header in enumerate(headers, start_col):
+                write(sh, start_row, col, header)
+
+        finally:
+            bytes_io = io.BytesIO()
+            wb.save(bytes_io)
+            bytes_io.seek(0)
+
+        return ResponseMixin.stream(bytes_io, is_xlsx=True)

fastgenerateapi/api_view/mixin/utils/zip_util.py

@@ -0,0 +1,50 @@
+import io
+import os
+import zipfile
+from typing import Union
+
+
+class ZipUtil:
+
+    @staticmethod
+    def folder_to_zip(folder_path: str, zip_path: Union[str, io.BytesIO]):
+        """
+        把文件夹打包成zip
+        :param folder_path: 文件夹路径
+        :param zip_path: 打包后zip路径
+        :return:
+        """
+        # 创建一个 ZIP 文件对象，使用 'w' 模式表示写入
+        with zipfile.ZipFile(zip_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+            # 遍历文件夹及其子文件夹
+            for root, dirs, files in os.walk(folder_path):
+                # 处理当前目录，将其添加到压缩包中，实现打包空文件夹
+                relative_path = os.path.relpath(root, folder_path)
+                if relative_path and relative_path != ".":
+                    # 确保相对路径不是空字符串，避免将根目录重复添加
+                    zip_info = zipfile.ZipInfo(relative_path + '/')
+                    zipf.writestr(zip_info, '')
+                # 处理文件
+                for file in files:
+                    # 获取文件的完整路径
+                    file_path = os.path.join(root, file)
+                    # 获取文件相对于文件夹的相对路径
+                    relative_path = os.path.relpath(file_path, folder_path)
+                    # 将文件添加到 ZIP 文件中
+                    zipf.write(file_path, relative_path)
+
+    @staticmethod
+    def folder_to_zip_bytes_io(folder_path: str):
+        """
+        把文件夹打包zip后转换成io格式
+        :param folder_path: 文件夹路径
+        :return:
+        """
+        bytes_io = io.BytesIO()
+        ZipUtil.folder_to_zip(folder_path, bytes_io)
+        bytes_io.seek(0)
+        return bytes_io
+
+
+
+

fastgenerateapi/api_view/switch_view.py

@@ -6,9 +6,9 @@ from starlette.responses import JSONResponse
 
 from fastgenerateapi.api_view.base_view import BaseView
 from fastgenerateapi.schemas_factory import response_factory, get_one_schema_factory
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 from fastgenerateapi.utils.exception import NOT_FOUND
-from fastgenerateapi.utils.parse_str import parse_str_to_bool
+from fastgenerateapi.utils.str_util import parse_str_to_bool
 
 
 class SwitchView(BaseView):

fastgenerateapi/api_view/update_relation_view.py

@@ -10,9 +10,9 @@ from tortoise.transactions import atomic
 from fastgenerateapi.api_view.base_view import BaseView
 from fastgenerateapi.api_view.mixin.save_mixin import SaveMixin
 from fastgenerateapi.data_type.data_type import DEPENDENCIES
-from fastgenerateapi.pydantic_utils.base_model import IDList
+from fastgenerateapi.pydantic_utils.base_model import IdList
 from fastgenerateapi.schemas_factory import response_factory
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 from fastgenerateapi.utils.exception import NOT_FOUND
 
 
@@ -20,7 +20,7 @@ class UpdateRelationView(BaseView, SaveMixin):
 
     path_id_name: str
     relation_id_name: str
-    update_relation_schema: Optional[Type[BaseModel]] = IDList
+    update_relation_schema: Optional[Type[BaseModel]] = IdList
     update_relation_route: Union[bool, DEPENDENCIES] = True
     """
     path_id_name: 路径id在模型中对应的字段名

fastgenerateapi/api_view/update_view.py

@@ -12,7 +12,7 @@ from fastgenerateapi.api_view.mixin.save_mixin import SaveMixin
 from fastgenerateapi.data_type.data_type import DEPENDENCIES, CALLABLE
 from fastgenerateapi.pydantic_utils.base_model import BaseModel
 from fastgenerateapi.schemas_factory import update_schema_factory, get_one_schema_factory, response_factory
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 from fastgenerateapi.utils.exception import NOT_FOUND
 
 

fastgenerateapi/cache/cache_decorator.py

@@ -1,4 +1,4 @@
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 
 
 def get_one_cache_decorator(func):

fastgenerateapi/controller/filter_controller.py

@@ -1,9 +1,50 @@
-from typing import Union, Any
+from datetime import datetime, date, time
+from typing import Union, Any, Optional
 
 from tortoise.expressions import Q
 from tortoise.queryset import QuerySet
 
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
+
+
+class FilterUtils:
+
+    @staticmethod
+    def date_to_datetime_23(date_value: Union[None, str, date, datetime]) -> Optional[datetime]:
+        """
+        使用场景：如创建时间筛选2025-01-01 至 2025-12-31；由于储存数据为datetime类型，会导致2025-12-31当天数据不包含
+        :param cls:
+        :param date_value:
+        :return:
+        """
+        if date_value is None:
+            return None
+
+        # 如果 date_value 是字符串，尝试解析为日期
+        if isinstance(date_value, str):
+            try:
+                # 尝试解析为 date 类型，这里假设日期字符串的格式是 YYYY-MM-DD
+                parsed_date = datetime.strptime(date_value, '%Y-%m-%d').date()
+            except ValueError:
+                # 如果解析失败，则尝试解析为 datetime 类型（可能包含时间信息）
+                try:
+                    parsed_datetime = datetime.strptime(date_value, '%Y-%m-%d %H:%M:%S')
+                    parsed_date = parsed_datetime.date()
+                except ValueError:
+                    # 如果仍然失败，则返回 None
+                    return None
+
+        # 如果 date_value 已经是 date 类型，直接使用
+        elif isinstance(date_value, date):
+            parsed_date = date_value
+
+        # 其他类型返回 None
+        else:
+            return None
+
+        # 将日期加上时间 "23:59:59" 转换为 datetime 类型
+        result_datetime = datetime.combine(parsed_date, datetime.min.time().replace(hour=23, minute=59, second=59))
+        return result_datetime
 
 
 class BaseFilter:
@@ -14,37 +55,36 @@ class BaseFilter:
     def __init__(self, filter_str: Union[str, tuple]):
         """
         :param filter_str:  Union[str, tuple]
+            当tuple时，第一个为str，后面参数无顺序和数量要求，可以是 类型、重命名字符串、用于修改传值的方法
         example： name__contains or (create_at__gt, datetime) or (create_at__gt, datetime, create_time)
         """
         field_type = str
         model_field = filter_str
-        filter_field = filter_str
-        if isinstance(filter_str, str):
-            if settings.app_settings.FILTER_UNDERLINE_WHETHER_DOUBLE_TO_SINGLE and "__" in filter_str:
-                filter_field = filter_str.replace("__", "_")
+        filter_field = None
+        filter_func = None
         # 判断filter表达式的类型
         if isinstance(filter_str, tuple):
             model_field = filter_str[0]
-            if len(filter_str) == 2:
-                if type(filter_str[1]) == type:
-                    field_type = filter_str[1]
-                    if settings.app_settings.FILTER_UNDERLINE_WHETHER_DOUBLE_TO_SINGLE and "__" in filter_str:
-                        filter_field = model_field.replace("__", "_")
-                    else:
-                        filter_field = model_field
-                else:
-                    filter_field = filter_str[1]
-            elif len(filter_str) > 2:
-                if type(filter_str[1]) == type:
-                    field_type = filter_str[1]
-                    filter_field = filter_str[2]
-                else:
-                    field_type = filter_str[2]
-                    filter_field = filter_str[1]
+            filter_field = filter_str[0]
+            for f in filter_str[1:]:
+                if type(f) == type:
+                    field_type = f
+                    continue
+                if type(f) == str:
+                    filter_field = f
+                    continue
+                if callable(f):
+                    filter_func = f
+        if not filter_field:
+            if settings.app_settings.FILTER_UNDERLINE_WHETHER_DOUBLE_TO_SINGLE:
+                filter_field = model_field.replace("__", "_")
+            else:
+                filter_field = model_field
 
+        self.field_type = field_type
         self.model_field = model_field
         self.filter_field = filter_field
-        self.field_type = field_type
+        self.filter_func = filter_func
 
     def generate_q(self, value: Union[str, list, bool]) -> Q:
         """
@@ -52,8 +92,8 @@ class BaseFilter:
         :param value:
         :return:
         """
-        if isinstance(value, str):
-            if value.upper() in ["NONE", "NULL", "NIL", "0"]:
+        if isinstance(value, (str, datetime, date, time)):
+            if hasattr(value, "upper") and value.upper() in ["NONE", "NULL", "NIL"]:
                 return eval(f"Q({self.model_field}={None})")
             return eval(f"Q({self.model_field}='{value}')")
         return eval(f"Q({self.model_field}={value})")
@@ -65,6 +105,8 @@ class BaseFilter:
         :param value:
         :return:
         """
+        if self.filter_func:
+            value = self.filter_func(value)
         queryset = queryset.filter(self.generate_q(value=value))
         return queryset
 
@@ -90,7 +132,7 @@ class FilterController:
         for k in values:
             f = self.filter_map.get(k, None)
             v = values[k]
-            if f is not None and (isinstance(v, bool) or v):
+            if f is not None and (v or v == 0 or isinstance(v, bool)):
                 queryset = f.query(queryset=queryset, value=v)
 
         return queryset

fastgenerateapi/controller/router_controller.py

@@ -1,7 +1,7 @@
 import inspect
 from typing import Union
 
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 from pydantic import BaseModel
 
 from fastgenerateapi.api_view.mixin.response_mixin import ResponseMixin
@@ -80,17 +80,17 @@ class RouterController:
             else:
                 middle_field = "_".join(middle_list)
             if method == "GET":
-                prefix_field = settings.app_settings.RESTFUL_GET_ROUTER_ADD_PREFIX
-                suffix_field = settings.app_settings.RESTFUL_GET_ROUTER_ADD_SUFFIX
+                prefix_field = settings.app_settings.RESTFUL_GET_ROUTER_ADD_PREFIX or ""
+                suffix_field = settings.app_settings.RESTFUL_GET_ROUTER_ADD_SUFFIX or ""
             elif method == "POST":
-                prefix_field = settings.app_settings.RESTFUL_POST_ROUTER_ADD_PREFIX
-                suffix_field = settings.app_settings.RESTFUL_POST_ROUTER_ADD_SUFFIX
+                prefix_field = settings.app_settings.RESTFUL_POST_ROUTER_ADD_PREFIX or ""
+                suffix_field = settings.app_settings.RESTFUL_POST_ROUTER_ADD_SUFFIX or ""
             elif method == "PUT":
-                prefix_field = settings.app_settings.RESTFUL_PUT_ROUTER_ADD_PREFIX
-                suffix_field = settings.app_settings.RESTFUL_PUT_ROUTER_ADD_SUFFIX
+                prefix_field = settings.app_settings.RESTFUL_PUT_ROUTER_ADD_PREFIX or ""
+                suffix_field = settings.app_settings.RESTFUL_PUT_ROUTER_ADD_SUFFIX or ""
             elif method == "DELETE":
-                prefix_field = settings.app_settings.RESTFUL_DELETE_ROUTER_ADD_PREFIX
-                suffix_field = settings.app_settings.RESTFUL_DELETE_ROUTER_ADD_SUFFIX
+                prefix_field = settings.app_settings.RESTFUL_DELETE_ROUTER_ADD_PREFIX or ""
+                suffix_field = settings.app_settings.RESTFUL_DELETE_ROUTER_ADD_SUFFIX or ""
             else:
                 prefix_field = ""
                 suffix_field = ""

fastgenerateapi/controller/rpc_controller.py

@@ -51,4 +51,4 @@ class RPCController(ResponseMixin):
         data = {}
         for base_param in self.data:
             data.setdefault(base_param.request_param_key, []).extend(base_param.model_field_value)
-        return data
+        return data

fastgenerateapi/controller/ws_controller.py

@@ -1,4 +1,4 @@
-from fastgenerateapi.settings.register_settings import settings
+from fastgenerateapi.settings.all_settings import settings
 
 
 class WsRouter: