fastgenerateapi 0.0.23__tar.gz → 0.0.25__tar.gz

{fastgenerateapi-0.0.23 → fastgenerateapi-0.0.25}/PKG-INFO

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

{fastgenerateapi-0.0.23 → fastgenerateapi-0.0.25}/fastgenerateapi/__version__.py

@@ -8,7 +8,7 @@
 #                                                  d8888P
 
 
-VERSION = (0, 0, 23)
+VERSION = (0, 0, 25)
 
 __version__ = '.'.join(map(str, VERSION))
 

{fastgenerateapi-0.0.23 → fastgenerateapi-0.0.25}/fastgenerateapi/api_view/base_view.py

@@ -1,3 +1,4 @@
+import time
 import uuid
 from copy import copy
 from typing import Optional, Type, List, Union, Sequence, Dict
@@ -9,7 +10,6 @@ from tortoise.queryset import QuerySet
 from pydantic import create_model, BaseModel
 from starlette.requests import Request
 from tortoise import Model
-from tortoise.expressions import Q
 
 from fastgenerateapi.api_view.mixin.base_mixin import BaseMixin
 from fastgenerateapi.api_view.mixin.dbmodel_mixin import DBModelMixin
@@ -55,25 +55,28 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
     def queryset(self) -> QuerySet:
         if not self.model_class:
             return self.error(msg="model_class not allow None")
-        if type(settings.app_settings.ACTIVE_DEFAULT_VALUE) == str:
-            queryset = self.model_class.filter(
-                eval(f"Q({settings.app_settings.WHETHER_DELETE_FIELD}={settings.app_settings.ACTIVE_DEFAULT_VALUE})"))
-        else:
-            queryset = self.model_class.filter(
-                eval(f"Q({settings.app_settings.WHETHER_DELETE_FIELD}={settings.app_settings.ACTIVE_DEFAULT_VALUE})"))
+
+        return self.get_active_queryset(self.model_class)
+
+    def get_active_queryset(self, model_class: Union[Type[Model], QuerySet, None] = None) -> QuerySet:
+        if not model_class:
+            if not self.model_class:
+                return self.error(msg="model_class not allow None")
+            model_class = self.model_class
+        delete_filter_field = settings.app_settings.WHETHER_DELETE_FIELD
+        if settings.app_settings.DELETE_FIELD_TYPE == "time":
+            delete_filter_field = f"{settings.app_settings.WHETHER_DELETE_FIELD}__isnull"
+        queryset = model_class.filter(**{
+            delete_filter_field: True
+        })
+
         return queryset
 
     @property
     def relation_queryset(self) -> QuerySet:
         if not self.relation_model_class:
             return self.error(msg="relation_model_class not allow None")
-        if type(settings.app_settings.ACTIVE_DEFAULT_VALUE) == str:
-            queryset = self.relation_model_class.filter(
-                eval(f"Q({settings.app_settings.WHETHER_DELETE_FIELD}='{settings.app_settings.ACTIVE_DEFAULT_VALUE}')"))
-        else:
-            queryset = self.relation_model_class.filter(
-                eval(f"Q({settings.app_settings.WHETHER_DELETE_FIELD}={settings.app_settings.ACTIVE_DEFAULT_VALUE})"))
-        return queryset
+        return self.get_active_queryset(self.relation_model_class)
 
     async def get_object(self, pk):
         model = await self.queryset.filter(pk=pk).prefetch_related(
@@ -83,6 +86,18 @@ class BaseView(BaseMixin, ResponseMixin, ToolMixin, DBModelMixin):
         else:
             raise NOT_FOUND
 
+    def _delete_value(self):
+        result = False
+        if settings.app_settings.DELETE_FIELD_TYPE == "time":
+            result = int(time.time() * 1000)
+        return result
+
+    async def delete_queryset(self, queryset: QuerySet):
+
+        await queryset.update(**{
+            settings.app_settings.WHETHER_DELETE_FIELD: self._delete_value()
+        })
+
     @staticmethod
     async def setattr_model(model: Model, prefetch_related_fields, *args, **kwargs) -> Model:
         for key, value_list in prefetch_related_fields.items():

{fastgenerateapi-0.0.23 → fastgenerateapi-0.0.25}/fastgenerateapi/api_view/delete_tree_view.py

@@ -38,17 +38,19 @@ class DeleteTreeView(BaseView):
 
         request_data.id_list = delete_id_list
         queryset = await self.get_del_tree_queryset(request_data=request_data, *args, **kwargs)
-        if unique_fields := self._get_unique_fields(self.model_class):
-            for model in await queryset:
-                model.is_active = False
-                for field in unique_fields:
-                    try:
-                        setattr(model, field, getattr(model, field) + f"__{int(time.time() * 1000)}")
-                    except Exception as e:
-                        setattr(model, field, getattr(model, field) + f"__{int(time.time() * 1000)}")
-                await model.save()
-        else:
-            await queryset.update(is_active=False)
+        await self.delete_queryset(queryset)
+
+        # if unique_fields := self._get_unique_fields(self.model_class):
+        #     for model in await queryset:
+        #         model.is_active = False
+        #         for field in unique_fields:
+        #             try:
+        #                 setattr(model, field, getattr(model, field) + f"__{int(time.time() * 1000)}")
+        #             except Exception as e:
+        #                 setattr(model, field, getattr(model, field) + f"__{int(time.time() * 1000)}")
+        #         await model.save()
+        # else:
+        #     await queryset.update(is_active=False)
         return
 
     async def get_del_tree_queryset(self, request_data, *args, **kwargs):

{fastgenerateapi-0.0.23 → fastgenerateapi-0.0.25}/fastgenerateapi/api_view/delete_view.py

@@ -26,18 +26,19 @@ class DeleteView(BaseView):
     @atomic()
     async def destroy(self, request_data, *args, **kwargs):
         queryset = await self.get_del_queryset(request_data=request_data, *args, **kwargs)
+        await self.delete_queryset(queryset)
 
-        if unique_fields := self._get_unique_fields(self.model_class):
-            for model in await queryset:
-                model.is_active = False
-                for field in unique_fields:
-                    try:
-                        setattr(model, field, getattr(model, field) + f"__{int(time.time() * 1000)}")
-                    except Exception as e:
-                        setattr(model, field, getattr(model, field) + f"__{int(time.time() * 1000)}")
-                await model.save()
-        else:
-            await queryset.update(is_active=False)
+        # if unique_fields := self._get_unique_fields(self.model_class):
+        #     for model in await queryset:
+        #         model.is_active = False
+        #         for field in unique_fields:
+        #             try:
+        #                 setattr(model, field, getattr(model, field) + f"__{int(time.time() * 1000)}")
+        #             except Exception as e:
+        #                 setattr(model, field, getattr(model, field) + f"__{int(time.time() * 1000)}")
+        #         await model.save()
+        # else:
+        #     await queryset.update(is_active=False)
         return
 
     async def get_del_queryset(self, request_data, *args, **kwargs):

{fastgenerateapi-0.0.23 → fastgenerateapi-0.0.25}/fastgenerateapi/api_view/get_tree_view.py

@@ -101,7 +101,8 @@ class GetTreeView(BaseView):
         if node_id:
             queryset = self.queryset.filter(pk=node_id).prefetch_related(settings.app_settings.DEFAULT_TREE_PARENT_FIELD)
             queryset = await self.get_tree_queryset(queryset, search, filters)
-            if not (top_node := await queryset.first()):
+            top_node = await queryset.first()
+            if not top_node:
                 raise NOT_FOUND
             top_nodes = [top_node]
         else:

{fastgenerateapi-0.0.23 → fastgenerateapi-0.0.25}/fastgenerateapi/api_view/mixin/dbmodel_mixin.py

@@ -19,10 +19,12 @@ class DBModelMixin:
 
         if type(fields) == str:
             try:
-                if field_info := model_class._meta.fields_map.get(fields):
-                    return field_info.description
-                elif fields.endswith("_id") and (field_info := model_class._meta.fields_map.get(fields.strip("_id"))):
+                field_info = model_class._meta.fields_map.get(fields)
+                field_info_fk = model_class._meta.fields_map.get(fields.rstrip("_id"))
+                if field_info:
                     return field_info.description
+                elif fields.endswith("_id") and field_info_fk:
+                    return field_info_fk.description
                 elif "__" in fields:
                     field_list = fields.split("__", maxsplit=1)
                     description = ""

{fastgenerateapi-0.0.23 → fastgenerateapi-0.0.25}/fastgenerateapi/example/models.py

@@ -4,15 +4,20 @@ from typing import Optional
 from pydantic.fields import FieldInfo
 from tortoise import Model, fields
 
+from common.model.base_model import TortoiseOrmAbstractModel
+from fastgenerateapi import my_fields
+from fastgenerateapi.my_fields.enum_field import IntEnumClass
+
 
 class StaffInfo(Model):
     """
         员工信息
     """
-    is_active: bool = fields.BooleanField(default=True, description="是否有效")
+    delete_at: Optional[datetime.datetime] = my_fields.SoftDeleteField()
+    created_at: Optional[datetime.datetime] = fields.DatetimeField(null=True, auto_now_add=True, description="创建时间")
+    category: Optional[IntEnumClass] = my_fields.IntEnumField(enum_list=["总经理", '主管', '员工'], description="职位分类")
     name: Optional[str] = fields.CharField(description="名字", max_length=255)
     age: Optional[int] = fields.IntField(description="年龄", default=None, null=True)
-    created_at: Optional[datetime.datetime] = fields.DatetimeField(null=True, auto_now_add=True, description="创建时间")
     company: fields.ForeignKeyNullableRelation["CompanyInfo"] = fields.ForeignKeyField(
         'models.CompanyInfo', related_name="staff", on_delete=fields.SET_NULL, default=None, null=True)
 
@@ -20,23 +25,24 @@ class StaffInfo(Model):
     def test(self):
         return "test"
 
+    @property
+    def category_name(self):
+        return self.category.name
+
     class PydanticMeta:
+        # 以下内容仅用于演示，存在重复和多余写法
         exclude = ["created_at"]
-        get_one_include = [
-            "name",
-            "company__name",
-            ("test", Optional[str], FieldInfo(default="", description="测试字段")),
-        ]
-        # get_all_include = []
-        # create_include = []
-        # update_include = []
+        get_include = ["category_name", "name"]
+        get_all_include = ["company__name"]
+        get_one_include = [("test", Optional[str], FieldInfo(default="", description="测试字段")), ]
+        save_exclude = ["category_name", "test"]
 
 
 class CompanyInfo(Model):
     """
         公司信息
     """
-    is_active: bool = fields.BooleanField(default=True, description="是否有效")
+    delete_at: Optional[datetime.datetime] = my_fields.SoftDeleteField()
     name: str = fields.CharField(description="岗位名称", max_length=255)
     boss_name: str = fields.CharField(description="老板名字", max_length=255)
     parent: fields.ForeignKeyNullableRelation["CompanyInfo"] = fields.ForeignKeyField(
@@ -48,3 +54,5 @@ class CompanyInfo(Model):
 
 
 
+
+

{fastgenerateapi-0.0.23 → fastgenerateapi-0.0.25}/fastgenerateapi/example/views.py

@@ -1,11 +1,11 @@
 from fastapi import Depends
-from starlette.websockets import WebSocket
-from tortoise import Tortoise
+from fastapi_cache.decorator import cache
 
-from fastgenerateapi import APIView, DeleteTreeView, GetTreeView, AsyncWebsocketConsumer, WebsocketView
+from fastgenerateapi import APIView, DeleteTreeView, GetTreeView
 from fastgenerateapi.deps import paginator_deps
+from middlewares.jwt_middleware.schemas import UserObject
 from modules.example.models import StaffInfo, CompanyInfo
-from modules.example.schemas import CompanyInfoRead, CompanyInfoCreate, TestSchema, ListTestSchema, StaffReadSchema
+from modules.example.schemas import CompanyInfoRead, CompanyInfoCreate, ListTestSchema, StaffReadSchema
 
 
 class CompanyView(APIView, DeleteTreeView, GetTreeView):
@@ -13,7 +13,8 @@ class CompanyView(APIView, DeleteTreeView, GetTreeView):
     # schema = CompanyInfoRead
     # create_schema = CompanyInfoCreate
 
-    async def view_get_list(self, paginator=Depends(paginator_deps())):
+    @cache()
+    async def view_get_list(self, paginator=Depends(paginator_deps())) -> ListTestSchema:
 
         return await self.pagination_data(queryset=self.queryset, fields=["id", "name"], paginator=paginator)
 
@@ -24,13 +25,22 @@ class StaffView(APIView):
         self.model_class = StaffInfo
         self.order_by_fields = ["-created_at"]
         self.prefetch_related_fields = {"company": ["name"]}
-        self.router_args = {
-            # "view_get_staff_list": ListTestSchema
-            "view_get_staff_list": TestSchema
-        }
+        # self.router_args = {
+        #     # "view_get_staff_list": ListTestSchema
+        #     "view_get_staff_list": TestSchema
+        # }
         self.get_all_schema = StaffReadSchema
+        # self.dependencies = [Depends(ADG.authenticate_user_deps), ]
         super().__init__()
 
+    # async def get_one(self, pk: str, *args, **kwargs) -> Union[BaseModel, dict, None]:
+    #     print(datetime.datetime.now())
+    #     data = await super().get_one(pk=pk, *args, **kwargs)
+    #     result = create_staff.delay()
+    #     print(result.id)
+    #     print(datetime.datetime.now())
+    #     return data
+
     # async def view_get_staff_list(self, name: Optional[str] = None):
     #     conn = Tortoise.get_connection("default")
     #     # conn = Tortoise.get_connection("local")
@@ -39,24 +49,26 @@ class StaffView(APIView):
     #     print(val)
     #     return self.success(data={"data_list": val})
 
+    @cache()
+    async def view_get_staff_list(
+            self,
+            paginator=Depends(paginator_deps()),
+            # current_user: UserObject = Depends(ADG.authenticate_user_deps),
+    ) -> ListTestSchema:
+        data = await self.pagination_data(queryset=self.queryset, fields=["id", "name"], paginator=paginator)
+        return self.success(data=data)
+
+
+# class StaffView(SQLGetAllView):
+#     table_name = "staffinfo"
+
+
+
+
+
+
+
 
-class ChatView(WebsocketView):
-    # redis_conn = default_redis
-    tags = ["ws测试"]
 
-    async def ws_wschat_pk(self, websocket: WebSocket, pk: str):
-        """
-        测试
-        """
-        await websocket.accept()
-        while True:
-            try:
-                data = await websocket.receive_json()
-                await websocket.send_text(f"接受到的消息是: {data}")
-            except Exception:
-                print(1)
 
 
-class Consumer(AsyncWebsocketConsumer):
-    # redis_conn = default_redis
-    ...

fastgenerateapi-0.0.25/fastgenerateapi/my_fields/__init__.py

@@ -0,0 +1,4 @@
+from fastgenerateapi.my_fields.pk_field import PrimaryKeyField
+from fastgenerateapi.my_fields.enum_field import IntEnumField
+from fastgenerateapi.my_fields.soft_delete_field import SoftDeleteField
+

fastgenerateapi-0.0.25/fastgenerateapi/my_fields/aes_field.py

@@ -0,0 +1,166 @@
+from typing import (
+    TYPE_CHECKING,
+    Any,
+    Callable,
+    Dict,
+    Generic,
+    List,
+    Optional,
+    Tuple,
+    Type,
+    TypeVar,
+    Union,
+    overload,
+)
+
+from passlib.handlers.pbkdf2 import pbkdf2_sha256
+from tortoise.fields import CharField
+
+from fastgenerateapi.utils.aes import AESCipher
+
+if TYPE_CHECKING:  # pragma: nocoverage
+    from tortoise.models import Model
+
+
+class AESField(CharField):
+    """
+    Character field.
+
+    You need provide the following:
+
+    ``salt`` (str): must
+        CBC加密需要一个十六位的key(密钥)和一个十六位iv(偏移量)
+    ``is_decrypt`` (str): default True 明文
+        返回结果是否明文
+    ``prefix`` (str): default $aes_
+        判断是否加密
+    """
+
+    def __init__(self, salt: str, is_decrypt: bool = True, prefix="$aes_", **kwargs: Any) -> None:
+        kwargs.setdefault("max_length", 255)
+        kwargs.setdefault("description", "加密字段")
+        self.salt = salt
+        self.prefix = prefix
+        self.is_decrypt = is_decrypt
+        super().__init__(**kwargs)
+
+    def to_db_value(self, value: Any, instance: "Union[Type[Model], Model]") -> Any:
+        """
+        Converts from the Python type to the DB type.
+        """
+        if value is not None:
+            if not isinstance(value, self.field_type):
+                value = self.field_type(value)  # pylint: disable=E1102
+            if not value.startswith(self.prefix):
+                value = self.prefix + AESCipher(self.salt).encrypt(value).decode("utf-8")
+
+        self.validate(value)
+        return value
+
+    def to_python_value(self, value: Any) -> Any:
+        """
+        Converts from the DB type to the Python type.
+        """
+        if value is not None:
+            if not isinstance(value, self.field_type):
+                value = self.field_type(value)  # pylint: disable=E1102
+            if value.startswith(self.prefix):
+                value = AESString(value[len(self.prefix):], self.salt, self.is_decrypt)
+
+        self.validate(value)
+        return value
+
+
+class AESString(object):
+    def __init__(self, value: str, salt: str, is_decrypt: bool = True):
+        self.value = value
+        self.salt = salt
+        self.is_decrypt = is_decrypt
+
+    def __str__(self):
+        if self.is_decrypt:
+            return self.decrypt_value
+        return self.value
+
+    @property
+    def decrypt_value(self):
+        return AESCipher(self.salt).decrypt(self.value).decode("utf-8")
+
+    def __len__(self):
+        return len(str(self))
+
+    def __getitem__(self, index):
+        return str(self)[index]
+
+    def __add__(self, other: Union["AESString", str]):
+        if isinstance(other, AESString):
+            other = str(other)
+        return str(self) + other
+
+    def __contains__(self, substring):
+        return substring in str(self)
+
+    def find(self, substring, start=0, end=None):
+        return str(self).find(substring, start, end)
+
+    def index(self, substring, start=0, end=None):
+        return str(self).index(substring, start, end)
+
+    def split(self, sep=None, maxsplit=-1):
+        return str(self).split(sep, maxsplit)
+
+    def replace(self, old, new, count=-1):
+        return str(self).replace(old, new, count)
+
+    def startswith(self, prefix, start=0, end=None):
+        return str(self).startswith(prefix, start, end)
+
+    def endswith(self, suffix, start=0, end=None):
+        return str(self).endswith(suffix, start, end)
+
+    def __mul__(self, n):
+        return str(self) * n
+
+    def __rmul__(self, n):
+        return self.__mul__(n)
+
+    def capitalize(self):
+        return str(self).capitalize()
+
+    def title(self):
+        return str(self).title()
+
+    def upper(self):
+        return str(self).upper()
+
+    def lower(self):
+        return str(self).lower()
+
+    def swapcase(self):
+        return str(self).swapcase()
+
+    def strip(self, chars=None):
+        return str(self).strip(chars)
+
+    def lstrip(self, chars=None):
+        return str(self).lstrip(chars)
+
+    def rstrip(self, chars=None):
+        return str(self).rstrip(chars)
+
+    def count(self, sub, start=0, end=None):
+        return str(self).count(sub, start, end)
+
+    def join(self, iterable):
+        return str(self).join(iterable)
+
+    def encode(self, encoding='utf-8', errors='strict'):
+        return str(self).encode(encoding, errors)
+
+
+
+
+
+
+
+