rainycode 1.0.0__py3-none-any.whl

common/aiorequests.py

@@ -0,0 +1,31 @@
+import json
+import aiohttp
+
+
+def parse_url(url, params=None, suffix=None):
+    if params:
+        query = "&".join(["{}={}".format(k, params[k]) for k in sorted(params.keys())])
+        if "?" in url:
+            url += "&" + query
+        else:
+            url += "?" + query
+    if suffix:
+        url += suffix
+    return url
+
+
+async def get(url, params=None, headers=None, suffix=None):
+    url = parse_url(url, params, suffix)
+    async with aiohttp.ClientSession(trust_env=True) as session:
+        async with session.get(url, headers=headers) as response:
+            text = await response.text()
+            return json.loads(text)
+
+
+async def post(url, data=None, headers=None):
+    async with aiohttp.ClientSession(trust_env=True) as session:
+        if isinstance(data, dict):
+            data = json.dumps(data)
+        async with session.post(url, data=data, headers=headers) as response:
+            text = await response.text()
+            return json.loads(text)

common/consts.py

@@ -0,0 +1,3 @@
+REDIS_PREFIX_REFRESH_TOKEN: str = "auth:refresh:"
+REDIS_PREFIX_USER_INFO: str = "user:info:"
+REDIS_PREFIX_BLOCKLIST: str = "auth:blocklist:"

common/exception.py

@@ -0,0 +1,68 @@
+from common.logging import logger
+from typing import cast
+from common.response import ErrorReturn
+from fastapi import HTTPException, Request, status
+from fastapi.exceptions import RequestValidationError, ResponseValidationError
+from starlette.responses import JSONResponse
+
+
+class CustomException(Exception):
+    """自定义异常"""
+    def __init__(
+        self, 
+        msg: str | None = None,
+        code: int = 0, 
+        data: object | None = None,
+        status_code: int = status.HTTP_500_INTERNAL_SERVER_ERROR
+    ) -> None:
+        super().__init__(msg)
+        self.msg = msg
+        self.code = code
+        self.data = data
+        self.status_code = status_code
+
+    def __str__(self) -> str:
+        return f'{self.msg}'
+
+async def CustomExceptionHandler(request: Request, exc: CustomException) -> JSONResponse:
+    """自定义异常处理器"""
+    exc = cast(CustomException, exc)
+    logger.error(f"请求地址: {request.url}, 错误信息: {exc.msg}, 错误详情: {exc.data}")
+    return ErrorReturn(data=exc.data, msg=exc.msg, code=exc.code, status_code=exc.status_code)
+
+
+async def HttpExceptionHandler(request: Request, exc: HTTPException) -> JSONResponse:
+    """HTTP异常处理器"""
+    logger.error(f"请求地址: {request.url}, 错误详情: {exc.detail}")
+    return ErrorReturn(data=None, msg=exc.detail)
+
+async def RequestValidationHandle(request: Request, exc: RequestValidationError):
+    """请求参数验证异常处理器"""
+    error_mapping = {
+        "Field required": "请求失败，缺少必填项！",
+        "value is not a valid list": "类型错误，提交参数应该为列表！", 
+        "value is not a valid int": "类型错误，提交参数应该为整数！",
+        "value could not be parsed to a boolean": "类型错误，提交参数应该为布尔值！",
+        "Input should be a valid list": "类型错误，输入应该是一个有效的列表！"
+    }
+    msg = error_mapping.get(exc.errors()[0].get('msg'), exc.errors()[0].get('msg'))
+    logger.error(f"请求地址: {request.url}, 错误信息: {msg}, 错误详情: {exc}")
+    return ErrorReturn(data=None, msg=msg, status_code=status.HTTP_422_UNPROCESSABLE_ENTITY)
+
+
+async def ResponseValidationHandle(request: Request, exc: ResponseValidationError) -> JSONResponse:
+    """响应参数验证异常处理器"""
+    logger.error(f"请求地址: {request.url}, 错误详情: {exc}")
+    return ErrorReturn(data=exc.body, msg=str(exc), status_code=status.HTTP_500_INTERNAL_SERVER_ERROR)
+
+
+async def ValueExceptionHandler(request: Request, exc: ValueError) -> JSONResponse:
+    """值异常处理器"""
+    logger.error(f"请求地址: {request.url}, 错误详情: {exc}")
+    return ErrorReturn(data=None, msg=str(exc))
+
+
+async def AllExceptionHandler(request: Request, exc: Exception) -> JSONResponse:
+    """全局异常处理器"""
+    logger.error(f"请求地址: {request.url}, 错误详情: {exc}")
+    return ErrorReturn(data=str(exc), msg='服务器内部错误', status_code=status.HTTP_500_INTERNAL_SERVER_ERROR)

common/logging.py

@@ -0,0 +1,84 @@
+import os
+import sys
+import logging
+import traceback
+
+
+def logging_config(app_name: str):
+    # 日志目录
+    log_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), "../log"))
+    if not os.path.exists(log_dir):
+        os.mkdir(log_dir)
+    file_path = log_dir + '/' + app_name + '.log'
+
+    return {
+        "version": 1,
+        # disable_existing_loggers 表示弃用已经存在的日志，True表示弃用，False表示不弃用。
+        "disable_existing_loggers": False,
+        "formatters": {
+            "default": {
+                "()": "uvicorn.logging.DefaultFormatter",
+                "fmt": "%(asctime)s %(levelname)s %(message)s",
+                "use_colors": None
+            },
+            "access": {
+                "()": "uvicorn.logging.AccessFormatter",
+                "fmt": "%(asctime)s %(levelname)s %(client_addr)s - \"%(request_line)s\" %(status_code)s"
+            },
+            'standard': {
+                'format': '%(asctime)s %(levelname)s %(message)s'
+            },
+        },
+        "handlers": {
+            "default": {
+                "formatter": "default",
+                "class": "logging.StreamHandler",
+                "stream": "ext://sys.stderr",
+            },
+            "access": {
+                "formatter": "access",
+                "class": "logging.StreamHandler",
+                "stream": "ext://sys.stdout",
+            },
+            "logfile": {
+                "level": "INFO",
+                "class": "logging.handlers.TimedRotatingFileHandler",  # 保存到文件，自动切
+                "filename": file_path,  # 日志文件的位置
+                "when": "midnight",  # 间间隔的类型
+                "interval": 1,  # 时间间隔
+                "backupCount": 60,  # 能留几个日志文件
+                "formatter": "standard",  # 使用哪种日志格式
+                "encoding": "utf-8",  # 保存的格式
+            }
+        },
+        "loggers": {
+            "uvicorn": {
+                "handlers": ["default", "logfile"],
+                "level": "INFO",
+                "propagate": False  # 向不向更高级别的logger传递
+            },
+            "uvicorn.error": {
+                "level": "INFO"
+            },
+            "uvicorn.access": {
+                # 隐藏该日志，防止和自定义的access日志冲突
+                # "handlers": ["access", "logfile"],
+                "level": "INFO",
+                "propagate": False
+            },
+            "fastapi": {
+                "handlers": ["default", "logfile"],
+                "level": "INFO",
+                "propagate": False
+            }
+        }
+    }
+
+
+def log_exc(e):
+    typ, value, tb = sys.exc_info()
+    logger.error(f"Uncaught exception {repr(value)}\nTraceback:{''.join(traceback.format_tb(tb))}")
+
+
+logger = logging.getLogger('fastapi')
+

common/response.py

@@ -0,0 +1,63 @@
+from pydantic import BaseModel, Field
+from starlette.background import BackgroundTask
+from starlette.responses import ContentStream, JSONResponse, StreamingResponse
+
+
+class ResponseSchema(BaseModel):
+    """响应模型"""
+    data: object | None = Field(default=None, description="响应数据")
+    msg: str | None = Field(description="响应消息")
+    code: int = Field(description="业务状态码")
+
+
+class SuccessReturn(JSONResponse):
+    """成功响应类"""
+    def __init__(
+            self,
+            data: object | None = None,
+            msg: str | None  = None,
+            code: int = 0,
+            status_code: int = 200
+    ) -> None:
+        content = ResponseSchema(
+            code=code,
+            msg=msg,
+            data=data,
+        ).model_dump()
+        super().__init__(content=content, status_code=status_code)
+
+
+class ErrorReturn(JSONResponse):
+    """错误响应类"""
+    def __init__(
+            self,
+            data: object | None = None,
+            msg: str | None = None,
+            code: int = -1,
+            status_code: int = 500,
+    ) -> None:
+        content = ResponseSchema(
+            code=code,
+            msg=msg,
+            data=data,
+        ).model_dump()
+        super().__init__(content=content, status_code=status_code)
+
+
+class StreamReturn(StreamingResponse):
+    """流式响应类"""
+    def __init__(
+            self,
+            data: ContentStream,
+            status_code: int = 200,
+            headers: dict[str, str] | None = None,
+            media_type: str | None = None,
+            background: BackgroundTask | None = None
+    ) -> None:
+        super().__init__(
+            content=data, 
+            status_code=status_code, 
+            media_type=media_type, # 文件类型
+            headers=headers, # 文件名
+            background=background # 文件大小
+        )

common_depend/auth_depend.py

@@ -0,0 +1,75 @@
+import json
+from fastapi import Depends, Request
+from fastapi.security import OAuth2PasswordBearer, SecurityScopes
+from common.consts import REDIS_PREFIX_BLOCKLIST, REDIS_PREFIX_USER_INFO
+from common.exception import CustomException
+from common_model.user_model import User
+from common_utlis.jwt_util import JwtUtil
+from core.databases.aioredis import AioRedis
+
+oauth2_scheme = OAuth2PasswordBearer(tokenUrl="api/auth_center/login")
+
+async def get_current_user(request: Request, token: str, security_scopes: SecurityScopes) -> User:
+    """
+    获取当前登录用户
+    """
+    payload = JwtUtil.decode_token(token)
+    if not payload:
+        raise CustomException(msg="无效的令牌")
+
+    # 检查是否在黑名单中
+    if await AioRedis.get(f"{REDIS_PREFIX_BLOCKLIST}{token}"):
+        raise CustomException(msg="令牌已失效")
+
+    user_id = payload.get("sub")
+    if not user_id:
+        raise CustomException(msg="无效的令牌")
+
+    # 1. 尝试从缓存获取
+    user = None
+    user_data = await AioRedis.get(f"{REDIS_PREFIX_USER_INFO}{user_id}")
+    if user_data:
+        user = User(**json.loads(user_data))
+
+    # 2. 缓存未命中，查库
+    if not user:
+        user = await User.get_or_none(id=user_id)
+        if user:
+            user_data = await user.model_dump()
+            await AioRedis.set(f"{REDIS_PREFIX_USER_INFO}{user_id}", json.dumps(user_data), ex=60 * 60 * 24)
+
+    if not user:
+        raise CustomException(msg="用户不存在")
+
+    if not user.is_active:
+        raise CustomException(msg="用户已被禁用")
+
+    permissions = []
+    if user.is_superuser:
+        permissions.append('*.*.*')
+    else:
+        # TODO 从数据库中查询用户权限
+        pass
+
+    # 设置请求上下文
+    request.state.user = user
+    return user
+
+
+async def login_require(request: Request, security_scopes: SecurityScopes, token=Depends(oauth2_scheme)) -> User:
+    """获取用户，获取不到报错"""
+    if not token:
+        raise CustomException('请先登录')
+
+    return await get_current_user(request, token, security_scopes)
+
+
+async def login_or_none(request: Request, security_scopes: SecurityScopes, token=Depends(oauth2_scheme)) -> User | None:
+    """获取用户，获取不到返回空"""
+    if not token:
+        return None
+
+    try:
+        return await get_current_user(request, token, security_scopes)
+    except Exception as e:
+        return None

common_model/base_model.py

@@ -0,0 +1,200 @@
+import uuid
+from collections.abc import Iterable
+from typing_extensions import Self
+from typing import Optional, Any
+from tortoise import fields, BaseDBAsyncClient
+from tortoise.expressions import Q
+from tortoise.queryset import BulkCreateQuery, QuerySet, QuerySetSingle
+from common_utlis.snowflake_util import get_snowflake_id
+from core.databases.aiodb import MySQLUtils
+
+
+class BaseModel(MySQLUtils):
+    
+    @classmethod
+    async def create(
+            cls,
+            using_db: Optional[BaseDBAsyncClient] = None,
+            **kwargs: Any
+    ) -> Self:
+        if not kwargs.get('id', 0) and 'id' in cls._meta.fields:
+            # uuid生成id
+            if kwargs.get('id_uuid', False):
+                kwargs['id'] = str(uuid.uuid4()).replace('-', '')
+            # 雪花算法生成id
+            if kwargs.get('id_snowflake', False):
+                kwargs['id'] = get_snowflake_id()
+        return await super().create(using_db=using_db, **kwargs)
+
+    @classmethod
+    def get(
+        cls,
+        *args: Q, 
+        using_db: BaseDBAsyncClient | None = None, 
+        **kwargs: Any
+    ) -> QuerySetSingle[Self]:
+        if 'deleted' in cls._meta.fields and kwargs.get('deleted', None) is None:
+            kwargs['deleted'] = False
+        return super().get(*args, using_db=using_db, **kwargs)
+
+    @classmethod
+    def filter(
+        cls, 
+        *args: Q, 
+        **kwargs: Any
+    ) -> QuerySet[Self]:
+        if 'deleted' in cls._meta.fields and kwargs.get('deleted', None) is None:
+            kwargs['deleted'] = False
+        return cls._meta.manager.get_queryset().filter(*args, **kwargs)
+
+    @classmethod
+    def bulk_create(
+            cls,
+            objects: Iterable[Self],
+            batch_size: Optional[int] = None,
+            ignore_conflicts: bool = False,
+            update_fields: Optional[Iterable[str]] = None,
+            on_conflict: Optional[Iterable[str]] = None,
+            using_db: Optional[BaseDBAsyncClient] = None,
+            **kwargs: Any
+    ) -> "BulkCreateQuery[Self]":
+        if 'id' in cls._meta.fields:
+            for obj in objects:
+                if not getattr(obj, 'id', 0):
+                    # uuid生成id
+                    if kwargs.get('id_uuid', False):
+                        obj.id = str(uuid.uuid4()).replace('-', '')
+                    # 雪花算法生成id
+                    if kwargs.get('id_snowflake', False):
+                        obj.id = get_snowflake_id()
+
+        params = {
+            "objects": objects,
+            "batch_size": batch_size,
+            "ignore_conflicts": ignore_conflicts,
+            "update_fields": update_fields,
+            "on_conflict": on_conflict,
+            "using_db": using_db,
+        }    
+        return super().bulk_create(**params)
+
+    async def save(
+            self,
+            using_db: Optional[BaseDBAsyncClient] = None,
+            update_fields: Optional[Iterable[str]] = None,
+            force_create: bool = False,
+            force_update: bool = False,
+            **kwargs: Any
+    ) -> None:
+        if not getattr(self, 'id', 0) and kwargs.get('uuid', False)  and 'id' in self._meta.fields:
+            setattr(self, 'id', str(uuid.uuid4()).replace('-', ''))
+        return await super().save(using_db=using_db, update_fields=update_fields, force_create=force_create,
+                                  force_update=force_update)
+
+
+class CreateModel(BaseModel):
+    deleted = fields.BooleanField(default=False, description='是否已删除')
+    create_time = fields.DatetimeField(auto_now_add=True, description='创建时间')
+    creator = fields.CharField(max_length=50, null=True, description="创建人")
+
+    class Meta:
+        abstract = True
+
+
+class UpdateModel(BaseModel):
+    deleted = fields.BooleanField(default=False, description='是否已删除')
+    create_time = fields.DatetimeField(auto_now_add=True, description='创建时间')
+    update_time = fields.DatetimeField(auto_now=True, description='更新时间')
+    creator = fields.CharField(max_length=50, null=True, description="创建人")
+    updater = fields.CharField(max_length=50, null=True, description="更新人")
+
+    class Meta:
+        abstract = True
+
+
+class DeleteModel(BaseModel):
+    deleted = fields.BooleanField(default=False, description="是否已删除")
+    create_time = fields.DatetimeField(auto_now_add=True, description="创建时间")
+    update_time = fields.DatetimeField(auto_now=True, description="更新时间")
+
+
+# class CreateRelatedMeta(type(Model)):
+#     """元类：更新外键字段，解决用户related_name重复问题"""
+#     def __new__(cls, name: str, bases: tuple, attrs: dict):
+#         if name == 'UpdateModel':
+#             return super().__new__(cls, name, bases, attrs)
+
+#         creator_related_name = f"{name.lower()}_creator"
+#         attrs["creator"] = fields.ForeignKeyField(
+#             'main.SystemUserModel',
+#             null=True,
+#             related_name=creator_related_name,
+#             db_constraint=False,
+#             description="创建人"
+#         )
+
+#         new_class = super().__new__(cls, name, bases, attrs)
+#         return new_class
+
+
+# class CreateModel(BaseModel, metaclass=CreateRelatedMeta):
+#     deleted = fields.BooleanField(default=False, description='是否已删除')
+#     create_time = fields.DatetimeField(auto_now_add=True, description='创建时间')
+#     creator = fields.ForeignKeyField(
+#         'main.SystemUserModel',
+#         null=True,
+#         db_constraint=False,
+#         description="创建人"
+#     )
+
+#     class Meta:
+#         abstract = True
+
+
+# class UpdateRelatedMeta(type(Model)):
+#     """元类：更新外键字段，解决用户related_name重复问题"""
+#     def __new__(cls, name: str, bases: tuple, attrs: dict):
+#         if name == 'UpdateModel':
+#             return super().__new__(cls, name, bases, attrs)
+
+#         creator_related_name = f"{name.lower()}_creator"
+#         attrs["creator"] = fields.ForeignKeyField(
+#             'main.SystemUserModel',
+#             null=True,
+#             related_name=creator_related_name,
+#             db_constraint=False,
+#             description="创建人"
+#         )
+
+#         updater_related_name = f"{name.lower()}_updater"
+#         attrs["updater"] = fields.ForeignKeyField(
+#             'main.SystemUserModel',
+#             null=True,
+#             related_name=updater_related_name,
+#             db_constraint=False,
+#             description="更新人"
+#         )
+
+#         new_class = super().__new__(cls, name, bases, attrs)
+#         return new_class
+
+# class UpdateModel(BaseModel, metaclass=UpdateRelatedMeta):
+#     deleted = fields.BooleanField(default=False, description='是否已删除')
+#     create_time = fields.DatetimeField(auto_now_add=True, description='创建时间')
+#     update_time = fields.DatetimeField(auto_now=True, description='更新时间')
+#     creator = fields.ForeignKeyField(
+#         'main.SystemUserModel',
+#         null=True,
+#         db_constraint=False,
+#         description="创建人"
+#     )
+
+#     updater = fields.ForeignKeyField(
+#         'main.SystemUserModel',
+#         null=True,
+#         db_constraint=False,
+#         description="更新人"
+#     )
+
+#     class Meta:
+#         abstract = True

common_model/user_model.py

@@ -0,0 +1,25 @@
+from tortoise import fields
+from common_model.base_model import UpdateModel
+
+
+class User(UpdateModel):
+    """
+    用户模型
+    """
+    id = fields.IntField(pk=True, description="主键")
+    username = fields.CharField(max_length=50, unique=True, description="用户名")
+    password = fields.CharField(max_length=128, description="密码(加密)")
+    email = fields.CharField(max_length=100, null=True, unique=True, description="邮箱")
+    phone = fields.CharField(max_length=20, null=True, unique=True, description="手机号")
+    nickname = fields.CharField(max_length=50, null=True, description="昵称")
+    avatar = fields.CharField(max_length=255, null=True, description="头像URL")
+    is_active = fields.BooleanField(default=True, description="是否激活")
+    is_superuser = fields.BooleanField(default=False, description="是否超级管理员")
+    last_login = fields.DatetimeField(null=True, description="最后登录时间")
+
+    class Meta:
+        table = "user"
+        table_description = "用户表"
+
+    class PydanticMeta:
+        exclude = ["password"]

common_model/wechat_model.py

@@ -0,0 +1,43 @@
+from tortoise import fields
+from enum import Enum
+from common_model.base_model import CreateModel
+
+class AppTypeEnum(str, Enum):
+    MINI_PROGRAM = "mini_program"
+    OFFICIAL_ACCOUNT = "official_account"
+
+
+class WechatApp(CreateModel):
+    """
+    微信应用配置表
+    """
+    id = fields.IntField(pk=True, description="主键")
+    app_name = fields.CharField(max_length=50, description="应用名称")
+    app_id = fields.CharField(max_length=50, description="微信AppID")
+    app_secret = fields.CharField(max_length=100, description="微信AppSecret")
+    token = fields.CharField(max_length=32, null=True, description="消息校验Token")
+    msg_secret = fields.CharField(max_length=43, null=True, description="消息加解密Key")
+    app_type = fields.CharEnumField(AppTypeEnum, description="应用类型")
+
+    class Meta:
+        table = "wechat_app"
+        table_description = "微信应用配置表"
+
+
+class WechatUser(CreateModel):
+    """
+    微信用户关联表
+    """
+    id = fields.IntField(pk=True, description="主键")
+    user = fields.ForeignKeyField("main.User", related_name="wechat_users", description="关联用户")
+    wechat_app = fields.ForeignKeyField("main.WechatApp", related_name="wechat_users", description="关联微信应用")
+    openid = fields.CharField(max_length=64, index=True, description="微信OpenID")
+    unionid = fields.CharField(max_length=64, null=True, index=True, description="微信UnionID")
+    session_key = fields.CharField(max_length=128, null=True, description="会话密钥(仅小程序)")
+    nickname = fields.CharField(max_length=64, null=True, description="微信昵称")
+    avatar = fields.CharField(max_length=255, null=True, description="微信头像")
+
+    class Meta:
+        table = "wechat_user"
+        table_description = "微信用户关联表"
+        unique_together = (("openid", "wechat_app"),)

common_utlis/bcrypt_util.py

@@ -0,0 +1,63 @@
+from passlib.context import CryptContext
+
+
+# 密码加密配置
+PwdContext = CryptContext(
+    schemes=["bcrypt"],
+    deprecated="auto",
+    bcrypt__rounds=12  # 设置加密轮数,增加安全性
+)
+
+
+class PwdUtil:
+    """
+    密码工具类,提供密码加密和验证功能
+    """
+
+    @classmethod
+    def verify_password(cls, plain_password: str, password_hash: str) -> bool:
+        """
+        校验密码是否匹配
+
+        Args:
+            plain_password: 明文密码
+            password_hash: 加密后的密码哈希值
+
+        Returns:
+            bool: 密码是否匹配
+        """
+        return PwdContext.verify(plain_password, password_hash)
+
+    @classmethod 
+    def set_password_hash(cls, password: str) -> str:
+        """
+        对密码进行加密
+
+        Args:
+            password: 明文密码
+
+        Returns:
+            str: 加密后的密码哈希值
+        """
+        return PwdContext.hash(password)
+
+    @classmethod
+    def check_password_strength(cls, password: str) -> str | None:
+        """
+        检查密码强度
+
+        Args:
+            password: 明文密码
+
+        Returns:
+            str: 如果密码强度不够返回提示信息,否则返回None
+        """
+        if len(password) < 6:
+            return "密码长度至少6位"
+        if not any(c.isupper() for c in password):
+            return "密码需要包含大写字母"
+        if not any(c.islower() for c in password):
+            return "密码需要包含小写字母" 
+        if not any(c.isdigit() for c in password):
+            return "密码需要包含数字"
+        return None