这是一封测试邮件，SMTP 配置「{name}」连接成功！
" + "发送时间：{time}
" + ).format(name=config.name, time=datetime.now().strftime("%Y-%m-%d %H:%M:%S")) + + try: + await send_email( + smtp_host=config.smtp_host, + smtp_port=config.smtp_port, + smtp_user=config.smtp_user, + smtp_password=config.smtp_password, + use_tls=config.use_tls, + from_name=config.from_name, + to_email=data.to_email, + to_name=None, + subject=subject, + body_html=body_html, + timeout=config.timeout, + ) + except Exception as e: + raise CustomException(msg=f"SMTP 连接测试失败：{e!s}") from e + + return {"message": f"测试邮件已发送至 {data.to_email}"} + + +class EmailTemplateService: + """邮件模板管理""" + + @classmethod + async def page_service( + cls, + auth: AuthSchema, + page_no: int, + page_size: int, + search: EmailTemplateQueryParam | None = None, + order_by: list | None = None, + ) -> dict: + return await EmailTemplateCRUD(auth).page( + offset=(page_no - 1) * page_size, + limit=page_size, + order_by=order_by or [{"id": "asc"}], + search=search.__dict__ if search else {}, + out_schema=EmailTemplateOutSchema, + ) + + @classmethod + async def detail_service(cls, auth: AuthSchema, id: int) -> EmailTemplateOutSchema: + obj = await EmailTemplateCRUD(auth).get(id=id) + if not obj: + raise CustomException(msg="邮件模板不存在") + return EmailTemplateOutSchema.model_validate(obj) + + @classmethod + async def create_service( + cls, auth: AuthSchema, data: EmailTemplateCreateSchema + ) -> EmailTemplateOutSchema: + existing = await EmailTemplateCRUD(auth).get_by_code( + template_code=data.template_code + ) + if existing: + raise CustomException(msg=f"模板编码「{data.template_code}」已存在") + + obj = await EmailTemplateCRUD(auth).create(data=data) + return EmailTemplateOutSchema.model_validate(obj) + + @classmethod + async def update_service( + cls, auth: AuthSchema, id: int, data: EmailTemplateUpdateSchema + ) -> EmailTemplateOutSchema: + obj = await EmailTemplateCRUD(auth).get(id=id) + if not obj: + raise CustomException(msg="邮件模板不存在") + + updated = await EmailTemplateCRUD(auth).update(id=id, data=data) + return EmailTemplateOutSchema.model_validate(updated) + + @classmethod + async def delete_service(cls, auth: AuthSchema, ids: list[int]) -> None: + if not ids: + raise CustomException(msg="删除对象不能为空") + await EmailTemplateCRUD(auth).delete(ids=ids) + + +class EmailSendService: + """ + 邮件发送服务 — 供其他模块调用。 + + 设计原则： + 1. 优先使用 is_default=True 的 SMTP 配置，无默认配置时降级为站内信（仅记录日志） + 2. 每次发送都写 platform_email_log + 3. 渲染失败/发送失败均记录 error_msg，不向调用方抛出异常（静默降级） + 4. 使用独立数据库会话：邮件发送失败不因调用方事务回滚而丢失日志 + """ + + @classmethod + async def send_by_template( + cls, + *, + to_email: str, + template_code: str, + variables: dict, + biz_type: str = "other", + to_name: str | None = None, + tenant_id: int | None = None, + config_id: int | None = None, + ) -> bool: + """ + 通过模板发送邮件（核心方法，供内部调用）。 + + 返回 True=发送成功，False=失败（已降级记录日志）。 + """ + # ① 获取模板（独立会话，不影响调用方事务） + async with async_db_session() as session: + auth = AuthSchema(db=session, check_data_scope=False) + template = await EmailTemplateCRUD(auth).get_active_by_code(template_code) + + if not template: + await EmailLogCRUD.create_log( + to_email=to_email, + subject=f"[{template_code}]", + biz_type=biz_type, + to_name=to_name, + template_code=template_code, + tenant_id=tenant_id, + status=2, + error_msg=f"模板「{template_code}」不存在或已禁用", + ) + return False + + # ② 渲染主题 & 正文 + try: + rendered_subject = render_template(template.subject, variables) + rendered_html = render_template(template.body_html, variables) + rendered_text = ( + render_template(template.body_text, variables) if template.body_text else None + ) + except Exception as e: + await EmailLogCRUD.create_log( + to_email=to_email, + subject=template.subject, + biz_type=biz_type, + to_name=to_name, + template_code=template_code, + tenant_id=tenant_id, + status=2, + error_msg=f"模板渲染失败：{e!s}", + ) + return False + + # ③ 获取 SMTP 配置（独立会话） + async with async_db_session() as session: + auth = AuthSchema(db=session, check_data_scope=False) + if config_id: + config = await EmailConfigCRUD(auth).get_active_by_id(config_id) + else: + config = await EmailConfigCRUD(auth).get_active_default() + + if not config: + await EmailLogCRUD.create_log( + to_email=to_email, + subject=rendered_subject, + biz_type=biz_type, + to_name=to_name, + template_code=template_code, + tenant_id=tenant_id, + status=2, + error_msg="无可用的 SMTP 配置，邮件未发送（已降级为站内信）", + ) + return False + + # ④ 发送 + try: + await send_email( + smtp_host=config.smtp_host, + smtp_port=config.smtp_port, + smtp_user=config.smtp_user, + smtp_password=config.smtp_password, + use_tls=config.use_tls, + from_name=config.from_name, + to_email=to_email, + to_name=to_name, + subject=rendered_subject, + body_html=rendered_html, + body_text=rendered_text, + timeout=config.timeout, + ) + except Exception as e: + await EmailLogCRUD.create_log( + to_email=to_email, + subject=rendered_subject, + biz_type=biz_type, + to_name=to_name, + template_code=template_code, + config_id=config.id, + tenant_id=tenant_id, + status=2, + error_msg=f"SMTP 发送失败：{e!s}", + ) + return False + + # ⑤ 写成功日志 + await EmailLogCRUD.create_log( + config_id=config.id, + template_code=template_code, + to_email=to_email, + to_name=to_name, + subject=rendered_subject, + biz_type=biz_type, + status=1, + tenant_id=tenant_id, + ) + + return True + + @classmethod + async def manual_send_service( + cls, auth: AuthSchema, data: EmailSendSchema + ) -> dict: + """超管手动触发发送（测试/补发用）""" + success = await cls.send_by_template( + to_email=data.to_email, + template_code=data.template_code, + variables=data.variables, + biz_type=data.biz_type, + to_name=data.to_name, + config_id=data.config_id, + ) + if not success: + raise CustomException(msg="邮件发送失败，请查看邮件日志获取详情") + return {"message": f"邮件已发送至 {data.to_email}"} + + +class EmailLogService: + """邮件日志查询""" + + @classmethod + async def page_service( + cls, + auth: AuthSchema, + page_no: int, + page_size: int, + search: EmailLogQueryParam | None = None, + order_by: list | None = None, + ) -> dict: + return await EmailLogCRUD(auth).page( + offset=(page_no - 1) * page_size, + limit=page_size, + order_by=order_by or [{"created_time": "desc"}], + search=search.__dict__ if search else {}, + out_schema=EmailLogOutSchema, + ) diff --git a/backend/app/api/v1/module_platform/invoice/__init__.py b/backend/app/api/v1/module_platform/invoice/__init__.py new file mode 100644 index 00000000..3a421edb --- /dev/null +++ b/backend/app/api/v1/module_platform/invoice/__init__.py @@ -0,0 +1,3 @@ +from .controller import PlatformInvoiceRouter, TenantInvoiceRouter + +__all__ = ["PlatformInvoiceRouter", "TenantInvoiceRouter"] diff --git a/backend/app/api/v1/module_platform/invoice/controller.py b/backend/app/api/v1/module_platform/invoice/controller.py new file mode 100644 index 00000000..85073150 --- /dev/null +++ b/backend/app/api/v1/module_platform/invoice/controller.py @@ -0,0 +1,171 @@ +"""发票管理 Controller""" +from typing import Annotated + +from fastapi import APIRouter, Body, Depends, Path, Query +from fastapi.responses import JSONResponse + +from app.common.response import ResponseSchema, SuccessResponse +from app.core.base_schema import AuthSchema, PageResultSchema +from app.core.dependencies import AuthPermission +from app.core.exceptions import CustomException +from app.core.router_class import OperationLogRoute + +from .crud import InvoiceCRUD +from .schema import ( + InvoiceApplySchema, + InvoiceIssueSchema, + InvoiceOutSchema, + InvoiceQueryParam, + InvoiceVoidSchema, +) +from .service import InvoicePlatformService, InvoiceTenantService + +# ========== 租户端 API ========== + +TenantInvoiceRouter = APIRouter(prefix="/tenant/invoice", route_class=OperationLogRoute, tags=["平台管理/发票管理"]) + + +@TenantInvoiceRouter.post("/apply", summary="申请开票", response_model=ResponseSchema[InvoiceOutSchema]) +async def invoice_apply( + data: Annotated[InvoiceApplySchema, Body()], + auth: Annotated[AuthSchema, Depends(AuthPermission(['*:*:*']))], +) -> JSONResponse: + """ + 申请开票 + + 参数: + - data (InvoiceApplySchema): 发票申请参数。 + + 返回: + - JSONResponse: 包含发票信息的 JSON 响应。 + """ + result = await InvoiceTenantService.apply(auth, data, auth.tenant_id) + return SuccessResponse(data=result, msg="发票申请成功") + + +@TenantInvoiceRouter.get("/list", summary="我的发票列表", response_model=ResponseSchema[PageResultSchema[InvoiceOutSchema]]) +async def invoice_list_my( + auth: Annotated[AuthSchema, Depends(AuthPermission(['*:*:*']))], + invoice_type: Annotated[str | None, Query()] = None, + status: Annotated[int | None, Query()] = None, + page_no: Annotated[int, Query(ge=1)] = 1, + page_size: Annotated[int, Query(ge=1, le=100)] = 10, +) -> JSONResponse: + """ + 我的发票列表 + + 参数: + - invoice_type (str | None): 发票类型筛选。 + - status (int | None): 状态筛选。 + - page_no (int): 页码。 + - page_size (int): 每页条数。 + + 返回: + - JSONResponse: 包含分页发票列表的 JSON 响应。 + """ + result = await InvoiceTenantService.list_my( + auth, auth.tenant_id, + InvoiceQueryParam(invoice_type=invoice_type, status=status, page_no=page_no, page_size=page_size), + ) + return SuccessResponse(data=result, msg="查询成功") + + +@TenantInvoiceRouter.get("/{id}/download", summary="下载发票PDF", response_model=ResponseSchema[dict]) +async def invoice_download( + id: Annotated[int, Path(ge=1)], + auth: Annotated[AuthSchema, Depends(AuthPermission(['*:*:*']))], +) -> JSONResponse: + """ + 下载发票 PDF + + 参数: + - id (int): 发票 ID。 + + 返回: + - JSONResponse: 包含 PDF 下载地址的 JSON 响应。 + """ + crud = InvoiceCRUD(auth) + invoice = await crud.get(id=id) + if not invoice: + raise CustomException(msg="发票不存在") + if hasattr(invoice, "tenant_id") and invoice.tenant_id != auth.tenant_id: + raise CustomException(msg="发票不存在") + if invoice.status != 1 or not invoice.pdf_url: + raise CustomException(msg="发票未开具或无PDF") + return SuccessResponse(msg="下载地址", data={"pdf_url": invoice.pdf_url}) + +# ========== 平台端 API ========== + + +PlatformInvoiceRouter = APIRouter(prefix="/invoice", route_class=OperationLogRoute, tags=["平台管理/发票管理"]) + + +@PlatformInvoiceRouter.get("/list", summary="全部发票列表", response_model=ResponseSchema[PageResultSchema[InvoiceOutSchema]]) +async def invoice_list_all( + auth: Annotated[AuthSchema, Depends(AuthPermission(['*:*:*']))], + invoice_type: Annotated[str | None, Query()] = None, + status: Annotated[int | None, Query()] = None, + tenant_id: Annotated[int | None, Query()] = None, + page_no: Annotated[int, Query(ge=1)] = 1, + page_size: Annotated[int, Query(ge=1, le=100)] = 10, +) -> JSONResponse: + """ + 全部发票列表（平台端） + + 参数: + - invoice_type (str | None): 发票类型筛选。 + - status (int | None): 状态筛选。 + - tenant_id (int | None): 租户 ID 筛选。 + - page_no (int): 页码。 + - page_size (int): 每页条数。 + + 返回: + - JSONResponse: 包含分页发票列表的 JSON 响应。 + """ + result = await InvoicePlatformService.list_all( + auth, + InvoiceQueryParam(invoice_type=invoice_type, status=status, tenant_id=tenant_id, page_no=page_no, page_size=page_size), + ) + return SuccessResponse(data=result, msg="查询成功") + + +@PlatformInvoiceRouter.put("/issue/{id}", summary="开具发票", response_model=ResponseSchema[InvoiceOutSchema]) +async def invoice_issue( + id: Annotated[int, Path(ge=1)], + data: Annotated[InvoiceIssueSchema, Body()], + auth: Annotated[AuthSchema, Depends(AuthPermission(['*:*:*']))], +) -> JSONResponse: + """ + 开具发票 + + 参数: + - id (int): 发票 ID。 + - data (InvoiceIssueSchema): 开票参数（PDF 链接等）。 + + 返回: + - JSONResponse: 包含发票信息的 JSON 响应。 + """ + result = await InvoicePlatformService.issue( + auth, id, data.pdf_url or "", data.api_response or "", + ) + return SuccessResponse(data=result, msg="发票开具成功") + + +@PlatformInvoiceRouter.put("/void/{id}", summary="作废发票", response_model=ResponseSchema[InvoiceOutSchema]) +async def invoice_void( + id: Annotated[int, Path(ge=1)], + auth: Annotated[AuthSchema, Depends(AuthPermission(['*:*:*']))], + data: Annotated[InvoiceVoidSchema, Body()] = InvoiceVoidSchema(), +) -> JSONResponse: + """ + 作废发票 + + 参数: + - id (int): 发票 ID。 + - data (InvoiceVoidSchema): 作废原因。 + + 返回: + - JSONResponse: 包含发票信息的 JSON 响应。 + """ + result = await InvoicePlatformService.void(auth, id, data) + return SuccessResponse(data=result, msg="发票已作废") diff --git a/backend/app/api/v1/module_platform/invoice/crud.py b/backend/app/api/v1/module_platform/invoice/crud.py new file mode 100644 index 00000000..30c381de --- /dev/null +++ b/backend/app/api/v1/module_platform/invoice/crud.py @@ -0,0 +1,16 @@ +"""发票管理 CRUD""" +from app.core.base_crud import CRUDBase +from app.core.base_schema import AuthSchema + +from .model import InvoiceModel +from .schema import InvoiceCreateSchema, InvoiceUpdateSchema + + +class InvoiceCRUD(CRUDBase[InvoiceModel, InvoiceCreateSchema, InvoiceUpdateSchema]): + """发票 CRUD —— 继承 CRUDBase 获得增删改查、软删除过滤、租户隔离、权限过滤""" + + def __init__(self, auth: AuthSchema) -> None: + super().__init__(model=InvoiceModel, auth=auth) + + async def get_by_order_id(self, order_id: int) -> InvoiceModel | None: + return await self.get(order_id=order_id) diff --git a/backend/app/api/v1/module_platform/invoice/model.py b/backend/app/api/v1/module_platform/invoice/model.py new file mode 100644 index 00000000..a193487a --- /dev/null +++ b/backend/app/api/v1/module_platform/invoice/model.py @@ -0,0 +1,26 @@ +"""发票管理 Model""" + +from sqlalchemy import ForeignKey, Integer, String, Text +from sqlalchemy.orm import Mapped, mapped_column + +from app.core.base_model import ModelMixin, TenantMixin + + +class InvoiceModel(ModelMixin, TenantMixin): + """平台发票表 platform_invoice + status: 0=待开票 1=已开票 2=开票失败 3=已作废 + """ + __tablename__ = "platform_invoice" + __table_args__: dict[str, str] = {"comment": "发票表"} + + invoice_no: Mapped[str] = mapped_column(String(32), nullable=False, unique=True, comment="发票号码") + order_id: Mapped[int] = mapped_column(Integer, ForeignKey("platform_order.id"), nullable=False, unique=True, comment="关联订单") + invoice_type: Mapped[str] = mapped_column(String(20), nullable=False, comment="vat_normal/vat_special") + title: Mapped[str] = mapped_column(String(200), nullable=False, comment="发票抬头") + tax_no: Mapped[str | None] = mapped_column(String(50), nullable=True, comment="纳税人识别号") + bank_info: Mapped[str | None] = mapped_column(Text, nullable=True, comment="开户行及账号") + address_info: Mapped[str | None] = mapped_column(Text, nullable=True, comment="注册地址及电话") + amount: Mapped[int] = mapped_column(Integer, nullable=False, comment="发票金额(分)") + tax_amount: Mapped[int] = mapped_column(Integer, nullable=False, default=0, comment="税额(分)") + pdf_url: Mapped[str | None] = mapped_column(String(500), nullable=True, comment="PDF下载地址") + api_response: Mapped[str | None] = mapped_column(Text, nullable=True, comment="第三方API响应") diff --git a/backend/app/api/v1/module_platform/invoice/schema.py b/backend/app/api/v1/module_platform/invoice/schema.py new file mode 100644 index 00000000..8b8edfc5 --- /dev/null +++ b/backend/app/api/v1/module_platform/invoice/schema.py @@ -0,0 +1,76 @@ +"""发票管理 Schema""" +from pydantic import BaseModel, ConfigDict, Field + +from app.core.base_schema import BaseSchema + + +class InvoiceCreateSchema(BaseModel): + """创建发票（内部使用）""" + invoice_no: str + order_id: int + tenant_id: int + invoice_type: str + title: str + tax_no: str | None = None + bank_info: str | None = None + address_info: str | None = None + amount: int + tax_amount: int = 0 + status: int = 0 + description: str | None = None + + +class InvoiceUpdateSchema(BaseModel): + """更新发票（内部使用）""" + status: int | None = None + pdf_url: str | None = None + api_response: str | None = None + description: str | None = None + + +class InvoiceApplySchema(BaseModel): + """申请开票""" + order_id: int = Field(..., description="订单ID") + invoice_type: str = Field(..., description="vat_normal/vat_special") + title: str = Field(..., max_length=200, description="发票抬头") + tax_no: str | None = Field(None, max_length=50, description="纳税人识别号") + bank_info: str | None = Field(None, description="开户行及账号") + address_info: str | None = Field(None, description="注册地址及电话") + description: str | None = Field(None, description="备注") + + +class InvoiceIssueSchema(BaseModel): + """超管开票""" + api_response: str | None = Field(None, description="第三方API响应（手动填入）") + pdf_url: str | None = Field(None, description="PDF下载地址") + + +class InvoiceVoidSchema(BaseModel): + """作废发票""" + description: str | None = Field(None, description="作废原因") + + +class InvoiceOutSchema(BaseSchema): + """发票列表输出""" + invoice_no: str + order_id: int + tenant_id: int + invoice_type: str + title: str + tax_no: str | None = None + bank_info: str | None = None + address_info: str | None = None + amount: int + tax_amount: int + pdf_url: str | None = None + + model_config = ConfigDict(from_attributes=True) + + +class InvoiceQueryParam(BaseModel): + """发票查询参数""" + invoice_type: str | None = Field(None, description="发票类型") + status: int | None = Field(None, description="状态") + tenant_id: int | None = Field(None, description="租户ID") + page_no: int = Field(1, ge=1) + page_size: int = Field(20, ge=1, le=100) diff --git a/backend/app/api/v1/module_platform/invoice/service.py b/backend/app/api/v1/module_platform/invoice/service.py new file mode 100644 index 00000000..d565a5d2 --- /dev/null +++ b/backend/app/api/v1/module_platform/invoice/service.py @@ -0,0 +1,167 @@ +"""发票管理 Service""" +import random +from datetime import date, datetime, timedelta + +from app.api.v1.module_platform.order.crud import OrderCRUD +from app.core.base_schema import AuthSchema +from app.core.exceptions import CustomException +from app.core.logger import logger + +from .crud import InvoiceCRUD +from .schema import ( + InvoiceApplySchema, + InvoiceCreateSchema, + InvoiceOutSchema, + InvoiceQueryParam, + InvoiceUpdateSchema, +) + + +def _generate_invoice_no() -> str: + """生成发票编号""" + today = date.today().strftime("%Y%m%d") + suffix = str(random.randint(100000, 999999)) + return f"INV{today}{suffix}" + + +class InvoiceTenantService: + """租户端发票服务""" + + @staticmethod + async def apply(auth: AuthSchema, data: InvoiceApplySchema, tenant_id: int) -> InvoiceOutSchema: + # 校验：专票必填字段 + if data.invoice_type == "vat_special": + if not data.tax_no: + raise CustomException(msg="增值税专用发票必须填写纳税人识别号") + if not data.bank_info: + raise CustomException(msg="增值税专用发票必须填写开户行及账号") + if not data.address_info: + raise CustomException(msg="增值税专用发票必须填写注册地址及电话") + + # 校验：订单存在且已支付 + order = await OrderCRUD(auth).get(id=data.order_id) + if not order: + raise CustomException(msg="订单不存在") + if order.status != 1: + raise CustomException(msg="仅已支付订单可申请开票") + + # 校验：30 天内 + if order.created_time and datetime.now() - order.created_time > timedelta(days=30): + raise CustomException(msg="订单支付超过 30 天，不可申请开票") + + crud = InvoiceCRUD(auth) + existing = await crud.get_by_order_id(data.order_id) + if existing: + raise CustomException(msg="该订单已申请过发票") + + tax_rate = 0 # 默认税率0%，未来可从套餐配置读取 + tax_amount = int(order.amount * tax_rate / 100) + invoice = await crud.create( + InvoiceCreateSchema( + invoice_no=_generate_invoice_no(), + order_id=data.order_id, + tenant_id=tenant_id, + invoice_type=data.invoice_type, + title=data.title, + tax_no=data.tax_no, + bank_info=data.bank_info, + address_info=data.address_info, + amount=order.amount, + tax_amount=tax_amount, + description=data.description, + ) + ) + logger.info(f"发票申请成功: invoice_no={invoice.invoice_no}, order_id={data.order_id}") + return InvoiceOutSchema.model_validate(invoice) + + @staticmethod + async def list_my(auth: AuthSchema, tenant_id: int, params: InvoiceQueryParam) -> dict: + search: dict = {"tenant_id": tenant_id} + if params.invoice_type: + search["invoice_type"] = params.invoice_type + if params.status is not None: + search["status"] = params.status + return await InvoiceCRUD(auth).page( + offset=(params.page_no - 1) * params.page_size, + limit=params.page_size, + order_by=[{"created_time": "desc"}], + search=search, + out_schema=InvoiceOutSchema, + ) + + +class InvoicePlatformService: + """平台端发票服务""" + + @staticmethod + async def list_all(auth: AuthSchema, params: InvoiceQueryParam) -> dict: + search: dict = {} + if params.invoice_type: + search["invoice_type"] = params.invoice_type + if params.status is not None: + search["status"] = params.status + if params.tenant_id: + search["tenant_id"] = params.tenant_id + return await InvoiceCRUD(auth).page( + offset=(params.page_no - 1) * params.page_size, + limit=params.page_size, + order_by=[{"created_time": "desc"}], + search=search, + out_schema=InvoiceOutSchema, + ) + + @staticmethod + async def issue(auth: AuthSchema, invoice_id: int, pdf_url: str, api_response: str) -> InvoiceOutSchema: + crud = InvoiceCRUD(auth) + invoice = await crud.get(id=invoice_id) + if not invoice: + raise CustomException(msg="发票不存在") + if invoice.status != 0: + raise CustomException(msg="仅待开票状态可操作") + + # 第三方开票 API 调用（暂为存根，对接百望云/票通时替换） + api_ok, pdf_url_result, api_response_result = await InvoicePlatformService._call_third_party_api(invoice) + + if not api_ok: + invoice = await crud.update(invoice_id, InvoiceUpdateSchema(status=2, api_response=api_response_result)) + logger.warning(f"第三方开票API调用失败: invoice_no={invoice.invoice_no}, resp={api_response_result}") + raise CustomException(msg=f"开票失败: {api_response_result}") + + invoice = await crud.update( + invoice_id, + InvoiceUpdateSchema( + status=1, + pdf_url=pdf_url or pdf_url_result, + api_response=api_response or api_response_result, + ), + ) + logger.info(f"发票开具成功: invoice_no={invoice.invoice_no}") + return InvoiceOutSchema.model_validate(invoice) + + @staticmethod + async def _call_third_party_api(invoice) -> tuple[bool, str, str]: + """第三方开票 API 存根 + + 对接百望云/票通等电子发票平台时替换此方法。 + 开发模式下直接模拟成功，返回 PDF 路径。 + + 返回: + (success: bool, pdf_url: str, api_response: str) + """ + pdf_url = f"/static/invoice/{invoice.tenant_id}/{invoice.invoice_no}.pdf" + api_response = '{"code":"SUCCESS","msg":"模拟开票成功","invoice_no":"' + invoice.invoice_no + '"}' + return True, pdf_url, api_response + + @staticmethod + async def void(auth: AuthSchema, invoice_id: int, data) -> InvoiceOutSchema: + crud = InvoiceCRUD(auth) + invoice = await crud.get(id=invoice_id) + if not invoice: + raise CustomException(msg="发票不存在") + if invoice.status != 1: + code_text = {0: "待开票", 2: "开票失败", 3: "已作废"}.get(invoice.status, "未知") + raise CustomException(msg=f"仅已开票状态可作废，当前状态: {code_text}") + description = getattr(data, "description", "") or "" + invoice = await crud.update(invoice_id, InvoiceUpdateSchema(status=3, description=description)) + logger.info(f"发票作废: invoice_no={invoice.invoice_no}") + return InvoiceOutSchema.model_validate(invoice) diff --git a/backend/app/api/v1/module_platform/loginlog/__init__.py b/backend/app/api/v1/module_platform/loginlog/__init__.py deleted file mode 100644 index 3b0a5fad..00000000 --- a/backend/app/api/v1/module_platform/loginlog/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from .controller import LoginLogRouter - -__all__ = ["LoginLogRouter"] diff --git a/backend/app/api/v1/module_platform/loginlog/controller.py b/backend/app/api/v1/module_platform/loginlog/controller.py deleted file mode 100644 index 445636b0..00000000 --- a/backend/app/api/v1/module_platform/loginlog/controller.py +++ /dev/null @@ -1,85 +0,0 @@ -from typing import Annotated - -from fastapi import APIRouter, Depends, Path - -from app.api.v1.module_system.auth.schema import AuthSchema -from app.common.response import ResponseSchema -from app.core.base_params import PaginationQueryParam -from app.core.base_schema import BatchDelete -from app.core.dependencies import AuthPermission, get_current_user - -from .schema import ( - LoginLogCreateSchema, - LoginLogDetailOutSchema, - LoginLogQueryParam, -) -from .service import LoginLogService - -LoginLogRouter = APIRouter(prefix="/loginlog", tags=["登录日志"]) - - -@LoginLogRouter.get( - "/detail/{id}", - summary="获取登录日志详情", - description="根据ID获取登录日志详情", - response_model=ResponseSchema[LoginLogDetailOutSchema], - dependencies=[Depends(AuthPermission("module_platform:login_log:query"))], -) -async def detail( - *, - id: Annotated[int, Path(gt=0)], - auth: AuthSchema = Depends(get_current_user), -): - return await LoginLogService.detail_service(auth, id) - - -@LoginLogRouter.get( - "/list", - summary="获取登录日志列表", - description="分页获取登录日志列表", - response_model=ResponseSchema[dict], - dependencies=[Depends(AuthPermission("module_platform:login_log:query"))], -) -async def list( - *, - page: Annotated[PaginationQueryParam, Depends()], - search: LoginLogQueryParam, - auth: AuthSchema = Depends(get_current_user), -): - return await LoginLogService.page_service( - auth, - page.page, - page.page_size, - search.to_dict(), - [{"id": page.order_by}], - ) - - -@LoginLogRouter.post( - "/create", - summary="创建登录日志", - description="创建登录日志（由系统自动调用）", - response_model=ResponseSchema[LoginLogDetailOutSchema], -) -async def create( - *, - data: LoginLogCreateSchema, - auth: AuthSchema = Depends(get_current_user), -): - return await LoginLogService.create_service(auth, data) - - -@LoginLogRouter.delete( - "/delete", - summary="删除登录日志", - description="批量删除登录日志", - response_model=ResponseSchema, - dependencies=[Depends(AuthPermission("module_platform:login_log:delete"))], -) -async def delete( - *, - data: BatchDelete, - auth: AuthSchema = Depends(get_current_user), -): - await LoginLogService.delete_service(auth, data.ids) - return ResponseSchema() diff --git a/backend/app/api/v1/module_platform/loginlog/crud.py b/backend/app/api/v1/module_platform/loginlog/crud.py deleted file mode 100644 index ff326ed4..00000000 --- a/backend/app/api/v1/module_platform/loginlog/crud.py +++ /dev/null @@ -1,11 +0,0 @@ -from app.api.v1.module_system.auth.schema import AuthSchema -from app.core.base_crud import CRUDBase - -from .model import LoginLogModel - - -class LoginLogCRUD(CRUDBase[LoginLogModel, None, None]): - """登录日志 CRUD""" - - def __init__(self, auth: AuthSchema): - super().__init__(LoginLogModel, auth) diff --git a/backend/app/api/v1/module_platform/loginlog/model.py b/backend/app/api/v1/module_platform/loginlog/model.py deleted file mode 100644 index f9c85a49..00000000 --- a/backend/app/api/v1/module_platform/loginlog/model.py +++ /dev/null @@ -1,20 +0,0 @@ -from sqlalchemy import Integer, String -from sqlalchemy.orm import Mapped, mapped_column - -from app.core.base_model import ModelMixin, UserMixin - - -class LoginLogModel(ModelMixin, UserMixin): - """ - 登录日志模型 - """ - - __tablename__: str = "platform_login_log" - __table_args__: dict[str, str] = {"comment": "登录日志表"} - - status: Mapped[int] = mapped_column(Integer, default=1, comment="登录状态(1成功 2失败)") - login_location: Mapped[str | None] = mapped_column(String(255), nullable=True, comment="登录位置") - login_ip: Mapped[str | None] = mapped_column(String(50), nullable=True, comment="登录IP地址") - request_os: Mapped[str | None] = mapped_column(String(64), nullable=True, comment="操作系统") - request_browser: Mapped[str | None] = mapped_column(String(64), nullable=True, comment="浏览器") - msg: Mapped[str | None] = mapped_column(String(255), nullable=True, comment="提示消息") diff --git a/backend/app/api/v1/module_platform/loginlog/schema.py b/backend/app/api/v1/module_platform/loginlog/schema.py deleted file mode 100644 index 11ff7a42..00000000 --- a/backend/app/api/v1/module_platform/loginlog/schema.py +++ /dev/null @@ -1,47 +0,0 @@ -from datetime import datetime - -from pydantic import BaseModel, ConfigDict, Field, field_validator - - -class LoginLogQueryParam(BaseModel): - status: int | None = Field(None, ge=1, le=2, description="登录状态(1成功 2失败)") - username: str | None = Field(None, max_length=64, description="用户名") - - def to_dict(self) -> dict | None: - """转换为字典，仅包含非空字段""" - return self.model_dump(exclude_none=True) - - -class LoginLogOutSchema(BaseModel): - model_config = ConfigDict(from_attributes=True) - - id: int - username: str - status: int - login_ip: str | None = None - login_location: str | None = None - request_os: str | None = None - request_browser: str | None = None - msg: str | None = None - created_at: datetime - - -class LoginLogDetailOutSchema(LoginLogOutSchema): - pass - - -class LoginLogCreateSchema(BaseModel): - username: str = Field(..., min_length=1, max_length=64, description="用户名") - status: int = Field(1, ge=1, le=2, description="登录状态(1成功 2失败)") - login_ip: str | None = Field(None, max_length=50, description="登录IP地址") - login_location: str | None = Field(None, max_length=255, description="登录位置") - request_os: str | None = Field(None, max_length=64, description="操作系统") - request_browser: str | None = Field(None, max_length=64, description="浏览器") - msg: str | None = Field(None, max_length=255, description="提示消息") - - @field_validator("status") - @classmethod - def validate_status(cls, value: int) -> int: - if value not in [1, 2]: - raise ValueError("登录状态只能为1(成功)或2(失败)") - return value diff --git a/backend/app/api/v1/module_platform/loginlog/service.py b/backend/app/api/v1/module_platform/loginlog/service.py deleted file mode 100644 index 70d31984..00000000 --- a/backend/app/api/v1/module_platform/loginlog/service.py +++ /dev/null @@ -1,55 +0,0 @@ -from app.api.v1.module_system.auth.schema import AuthSchema -from app.api.v1.module_platform.loginlog.crud import LoginLogCRUD -from app.api.v1.module_platform.loginlog.schema import ( - LoginLogCreateSchema, - LoginLogDetailOutSchema, - LoginLogOutSchema, -) -from app.core.logger import log - - -class LoginLogService: - @staticmethod - async def create_service(auth: AuthSchema, data: LoginLogCreateSchema) -> LoginLogDetailOutSchema: - crud = LoginLogCRUD(auth) - obj = await crud.create(data.model_dump()) - return LoginLogDetailOutSchema.model_validate(obj) - - @staticmethod - async def page_service( - auth: AuthSchema, - page: int, - page_size: int, - search: dict | None = None, - order_by: list[dict[str, str]] | None = None, - ) -> dict: - crud = LoginLogCRUD(auth) - - # 构建过滤条件 - filters = {} - if search: - if search.get("status"): - filters["status"] = search["status"] - if search.get("username"): - filters["username"] = search["username"] - - result = await crud.page( - offset=(page - 1) * page_size, - limit=page_size, - order_by=order_by or [{"id": "desc"}], - search=filters, - out_schema=LoginLogOutSchema, - ) - return result - - @staticmethod - async def detail_service(auth: AuthSchema, id: int) -> LoginLogDetailOutSchema: - crud = LoginLogCRUD(auth) - obj = await crud.get(id=id) - return LoginLogDetailOutSchema.model_validate(obj) - - @staticmethod - async def delete_service(auth: AuthSchema, ids: list[int]) -> None: - crud = LoginLogCRUD(auth) - await crud.delete(ids) - log.info(f"删除登录日志成功, ids={ids}") diff --git a/backend/app/core/middleware/__init__.py b/backend/app/api/v1/module_platform/menu/__init__.py similarity index 100% rename from backend/app/core/middleware/__init__.py rename to backend/app/api/v1/module_platform/menu/__init__.py diff --git a/backend/app/api/v1/module_system/menu/controller.py b/backend/app/api/v1/module_platform/menu/controller.py similarity index 76% rename from backend/app/api/v1/module_system/menu/controller.py rename to backend/app/api/v1/module_platform/menu/controller.py index 73cbcf08..b215ec95 100644 --- a/backend/app/api/v1/module_system/menu/controller.py +++ b/backend/app/api/v1/module_platform/menu/controller.py @@ -2,29 +2,31 @@ from typing import Annotated from fastapi import APIRouter, Body, Depends, Path from fastapi.responses import JSONResponse +from fastapi_cache import FastAPICache +from fastapi_cache.decorator import cache -from app.api.v1.module_system.auth.schema import AuthSchema from app.common.response import ResponseSchema, SuccessResponse -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable from app.core.dependencies import AuthPermission -from app.core.logger import log from app.core.router_class import OperationLogRoute from .schema import MenuCreateSchema, MenuOutSchema, MenuQueryParam, MenuUpdateSchema from .service import MenuService -MenuRouter = APIRouter(route_class=OperationLogRoute, prefix="/menu", tags=["菜单管理"]) +MenuRouter = APIRouter(route_class=OperationLogRoute, prefix="/menu", tags=["平台管理/菜单管理"]) + +_MENU_NS = "menu" @MenuRouter.get( "/tree", summary="查询菜单树", - description="查询菜单树", response_model=ResponseSchema[list[MenuOutSchema]], ) +@cache(expire=300, namespace=_MENU_NS) async def get_menu_tree_controller( search: Annotated[MenuQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:menu:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:menu:query']))], ) -> JSONResponse: """ 查询菜单树。 @@ -39,19 +41,17 @@ async def get_menu_tree_controller( result_dict_list = await MenuService.get_menu_tree_service( search=search, auth=auth, order_by=order_by ) - log.info("查询菜单树成功") return SuccessResponse(data=result_dict_list, msg="查询菜单树成功") @MenuRouter.get( "/detail/{id}", summary="查询菜单详情", - description="查询菜单详情", response_model=ResponseSchema[MenuOutSchema], ) async def get_obj_detail_controller( id: Annotated[int, Path(description="菜单ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:menu:detail"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:menu:detail']))], ) -> JSONResponse: """ 查询菜单详情。 @@ -63,19 +63,17 @@ async def get_obj_detail_controller( - JSONResponse: 包含菜单详情的 JSON 响应。 """ result_dict = await MenuService.get_menu_detail_service(id=id, auth=auth) - log.info(f"查询菜单详情成功 {id}") return SuccessResponse(data=result_dict, msg="查询菜单详情成功") @MenuRouter.post( "/create", summary="创建菜单", - description="创建菜单", response_model=ResponseSchema[MenuOutSchema], ) async def create_obj_controller( data: MenuCreateSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:menu:create"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:menu:create']))], ) -> JSONResponse: """ 创建菜单。 @@ -87,20 +85,19 @@ async def create_obj_controller( - JSONResponse: 包含创建菜单的 JSON 响应。 """ result_dict = await MenuService.create_menu_service(data=data, auth=auth) - log.info(f"创建菜单成功: {result_dict}") + await FastAPICache.clear(namespace=_MENU_NS) return SuccessResponse(data=result_dict, msg="创建菜单成功") @MenuRouter.put( "/update/{id}", summary="修改菜单", - description="修改菜单", response_model=ResponseSchema[MenuOutSchema], ) async def update_obj_controller( data: MenuUpdateSchema, id: Annotated[int, Path(description="菜单ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:menu:update"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:menu:update']))], ) -> JSONResponse: """ 修改菜单。 @@ -113,19 +110,18 @@ async def update_obj_controller( - JSONResponse: 包含修改菜单的 JSON 响应。 """ result_dict = await MenuService.update_menu_service(id=id, data=data, auth=auth) - log.info(f"修改菜单成功: {result_dict}") + await FastAPICache.clear(namespace=_MENU_NS) return SuccessResponse(data=result_dict, msg="修改菜单成功") @MenuRouter.delete( "/delete", summary="删除菜单", - description="删除菜单", response_model=ResponseSchema[None], ) async def delete_obj_controller( ids: Annotated[list[int], Body(description="ID列表")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:menu:delete"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:menu:delete']))], ) -> JSONResponse: """ 删除菜单。 @@ -137,19 +133,18 @@ async def delete_obj_controller( - JSONResponse: 包含删除菜单的 JSON 响应。 """ await MenuService.delete_menu_service(ids=ids, auth=auth) - log.info(f"删除菜单成功: {ids}") + await FastAPICache.clear(namespace=_MENU_NS) return SuccessResponse(msg="删除菜单成功") @MenuRouter.patch( "/status/batch", summary="批量修改菜单状态", - description="批量修改菜单状态", response_model=ResponseSchema[None], ) async def batch_set_available_obj_controller( data: BatchSetAvailable, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:menu:patch"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:menu:patch']))], ) -> JSONResponse: """ 批量修改菜单状态。 @@ -161,5 +156,5 @@ async def batch_set_available_obj_controller( - JSONResponse: 批量修改菜单状态的 JSON 响应。 """ await MenuService.set_menu_available_service(data=data, auth=auth) - log.info(f"批量修改菜单状态成功: {data.ids}") + await FastAPICache.clear(namespace=_MENU_NS) return SuccessResponse(msg="批量修改菜单状态成功") diff --git a/backend/app/api/v1/module_platform/menu/crud.py b/backend/app/api/v1/module_platform/menu/crud.py new file mode 100644 index 00000000..66fbc9cb --- /dev/null +++ b/backend/app/api/v1/module_platform/menu/crud.py @@ -0,0 +1,47 @@ +from collections.abc import Sequence + +from app.core.base_crud import CRUDBase +from app.core.base_schema import AuthSchema + +from .model import MenuModel +from .schema import MenuCreateSchema, MenuUpdateSchema + + +class MenuCRUD(CRUDBase[MenuModel, MenuCreateSchema, MenuUpdateSchema]): + """菜单模块数据层""" + + def __init__(self, auth: AuthSchema) -> None: + """ + 初始化菜单数据层。 + + 参数: + - auth (AuthSchema): 认证信息模型（含 DB 会话等上下文）。 + + 返回: + - None + """ + super().__init__(model=MenuModel, auth=auth) + + async def get_tree_list( + self, + search: dict | None = None, + order_by: list[dict] | None = None, + preload: list[str] | None = None, + ) -> Sequence[MenuModel]: + """ + 获取菜单树形列表。 + + 参数: + - search (dict | None): 搜索条件。 + - order_by (list[dict] | None): 排序字段列表。 + - preload (list[str] | None): 预加载关系，未提供时使用模型默认项 + + 返回: + - Sequence[MenuModel]: 菜单树形列表。 + """ + return await self.tree_list( + search=search, + order_by=order_by, + children_attr="children", + preload=preload, + ) diff --git a/backend/app/api/v1/module_system/menu/model.py b/backend/app/api/v1/module_platform/menu/model.py similarity index 74% rename from backend/app/api/v1/module_system/menu/model.py rename to backend/app/api/v1/module_platform/menu/model.py index 2695fda8..f021c2ed 100644 --- a/backend/app/api/v1/module_system/menu/model.py +++ b/backend/app/api/v1/module_platform/menu/model.py @@ -21,8 +21,8 @@ class MenuModel(ModelMixin): - 4: 外部链接 """ - __tablename__: str = "sys_menu" - __table_args__: dict[str, str] = {"comment": "菜单表"} + __tablename__: str = "platform_menu" + __table_args__: dict[str, str] = {"comment": "平台菜单表"} __loader_options__: list[str] = ["roles"] __permission_strategy__: PermissionFilterStrategy = PermissionFilterStrategy.ROLE_BASED @@ -75,11 +75,30 @@ class MenuModel(ModelMixin): server_default="pc", comment="终端(pc:管理端桌面 app:移动端)", ) + link: Mapped[str | None] = mapped_column(String(500), comment="外链地址(仅type=4)") + is_iframe: Mapped[bool] = mapped_column( + Boolean, default=False, nullable=False, comment="是否嵌入iframe(True:是 False:否)" + ) + is_hide_tab: Mapped[bool] = mapped_column( + Boolean, default=False, nullable=False, comment="是否隐藏标签页(True:是 False:否)" + ) + active_path: Mapped[str | None] = mapped_column(String(200), comment="激活菜单路径(用于高亮父级)") + show_badge: Mapped[bool] = mapped_column( + Boolean, default=False, nullable=False, comment="是否显示红点角标(True:是 False:否)" + ) + show_text_badge: Mapped[str | None] = mapped_column(String(20), comment="文字角标内容") + scope: Mapped[str] = mapped_column( + String(20), + nullable=False, + default="tenant", + server_default="tenant", + comment="菜单可见范围(platform:仅平台 tenant:租户可用)", + ) # 树形结构 parent_id: Mapped[int | None] = mapped_column( Integer, - ForeignKey("sys_menu.id", ondelete="SET NULL"), + ForeignKey("platform_menu.id", ondelete="SET NULL"), default=None, index=True, comment="父菜单ID", diff --git a/backend/app/api/v1/module_system/menu/schema.py b/backend/app/api/v1/module_platform/menu/schema.py similarity index 55% rename from backend/app/api/v1/module_system/menu/schema.py rename to backend/app/api/v1/module_platform/menu/schema.py index e21e3825..6af2f072 100644 --- a/backend/app/api/v1/module_system/menu/schema.py +++ b/backend/app/api/v1/module_platform/menu/schema.py @@ -30,17 +30,27 @@ class MenuCreateSchema(BaseModel): ) affix: bool = Field(default=False, description="是否固定标签页") parent_id: int | None = Field(default=None, ge=1, description="父菜单ID") - status: str = Field(default="0", max_length=1, description="状态(0:正常 1:禁用)") + status: int = Field(default=0, ge=0, le=1, description="状态(0:正常 1:禁用)") description: str | None = Field(default=None, max_length=255, description="描述") client: Literal["pc", "app"] = Field( default="pc", description="终端(pc:管理端桌面 app:移动端)", ) + link: str | None = Field(default=None, max_length=500, description="外链地址(仅type=4)") + is_iframe: bool = Field(default=False, description="是否嵌入iframe") + is_hide_tab: bool = Field(default=False, description="是否隐藏标签页") + active_path: str | None = Field(default=None, max_length=200, description="激活菜单路径") + show_badge: bool = Field(default=False, description="是否显示红点角标") + show_text_badge: str | None = Field(default=None, max_length=20, description="文字角标内容") + scope: Literal["platform", "tenant"] = Field( + default="tenant", + description="菜单可见范围(platform:仅平台 tenant:租户可用)", + ) @field_validator("status") @classmethod - def _validate_status(cls, v: str) -> str: - if v not in {"0", "1"}: + def _validate_status(cls, v: int) -> int: + if v not in {0, 1}: raise ValueError("状态仅支持 0(正常) 或 1(禁用)") return v @@ -59,6 +69,9 @@ class MenuCreateSchema(BaseModel): "redirect", "title", "description", + "link", + "active_path", + "show_text_badge", ]: if k in values and isinstance(values[k], str): values[k] = ( @@ -73,11 +86,7 @@ class MenuCreateSchema(BaseModel): values["parent_id"] = int(values["parent_id"].strip()) except (ValueError, TypeError): pass # parent_id 不是有效整数，保留原值 - # 路由名/路径规范 - if "route_path" in values and isinstance(values["route_path"], str): - rp = values["route_path"] - if rp and not rp.startswith("/"): - raise ValueError("路由路径需以 / 开头") + # 组件路径规范 if "component_path" in values and isinstance(values["component_path"], str): cp = values["component_path"] if cp and cp.startswith("/"): @@ -98,11 +107,79 @@ class MenuCreateSchema(BaseModel): return menu_request_validator(self) -class MenuUpdateSchema(MenuCreateSchema): - """菜单更新模型""" +class MenuUpdateSchema(BaseModel): + """菜单更新模型 — 所有字段可选""" + name: str | None = Field(default=None, min_length=1, max_length=50, description="菜单名称") + type: int | None = Field(default=None, ge=1, le=4, description="菜单类型(1:目录 2:菜单 3:按钮 4:外链)") + order: int | None = Field(default=None, ge=0, description="显示顺序") + permission: str | None = Field(default=None, max_length=100, description="权限标识") + icon: str | None = Field(default=None, max_length=50, description="菜单图标") + route_name: str | None = Field(default=None, max_length=100, description="路由名称") + route_path: str | None = Field(default=None, max_length=200, description="路由地址") + component_path: str | None = Field(default=None, max_length=200, description="组件路径") + redirect: str | None = Field(default=None, max_length=200, description="重定向地址") + hidden: bool | None = Field(default=None, description="是否隐藏") + keep_alive: bool | None = Field(default=None, description="是否缓存") + always_show: bool | None = Field(default=None, description="是否始终显示") + title: str | None = Field(default=None, max_length=50, description="菜单标题") + params: list[dict[str, str]] | None = Field(default=None, description="路由参数") + affix: bool | None = Field(default=None, description="是否固定标签页") + parent_id: int | None = Field(default=None, ge=1, description="父菜单ID") + status: int | None = Field(default=None, ge=0, le=1, description="状态(0:正常 1:禁用)") + description: str | None = Field(default=None, max_length=255, description="描述") + client: Literal["pc", "app"] | None = Field(default=None, description="终端(pc:管理端桌面 app:移动端)") + link: str | None = Field(default=None, max_length=500, description="外链地址(仅type=4)") + is_iframe: bool | None = Field(default=None, description="是否嵌入iframe") + is_hide_tab: bool | None = Field(default=None, description="是否隐藏标签页") + active_path: str | None = Field(default=None, max_length=200, description="激活菜单路径") + show_badge: bool | None = Field(default=None, description="是否显示红点角标") + show_text_badge: str | None = Field(default=None, max_length=20, description="文字角标内容") + scope: Literal["platform", "tenant"] | None = Field( + default=None, + description="菜单可见范围(platform:仅平台 tenant:租户可用)", + ) parent_name: str | None = Field(default=None, max_length=50, description="父菜单名称") + @field_validator("status") + @classmethod + def _validate_status(cls, v: int | None) -> int | None: + if v is None: + return v + if v not in {0, 1}: + raise ValueError("状态仅支持 0(正常) 或 1(禁用)") + return v + + @model_validator(mode="before") + @classmethod + def _normalize(cls, values): + if isinstance(values, dict): + for k in [ + "name", "icon", "permission", "route_name", "route_path", + "component_path", "redirect", "title", "description", + "link", "active_path", "show_text_badge", + ]: + if k in values and isinstance(values[k], str): + values[k] = values[k].strip() or None if values[k].strip() == "" else values[k].strip() + if "client" in values and isinstance(values["client"], str): + cv = values["client"].strip() + values["client"] = cv if cv in ("pc", "app") else None + if "parent_id" in values and isinstance(values["parent_id"], str): + try: + values["parent_id"] = int(values["parent_id"].strip()) + except (ValueError, TypeError): + pass + if "component_path" in values and isinstance(values["component_path"], str) and values["component_path"]: + if values["component_path"].startswith("/"): + raise ValueError("组件路径不能以 / 开头") + return values + + @model_validator(mode="after") + def validate_fields(self): + if self.type is None: + return self + return menu_request_validator(self) + class MenuOutSchema(MenuCreateSchema, BaseSchema): """菜单响应模型""" @@ -110,6 +187,7 @@ class MenuOutSchema(MenuCreateSchema, BaseSchema): model_config = ConfigDict(from_attributes=True) parent_name: str | None = Field(default=None, max_length=50, description="父菜单名称") + children: list["MenuOutSchema"] | None = Field(default=None, description="子菜单列表") class MenuQueryParam: @@ -142,6 +220,10 @@ class MenuQueryParam: None, description="管理端 Tab：pc=桌面端菜单 app=移动端菜单；不传则不过滤终端", ), + scope: Literal["tenant"] | None = Query( + None, + description="菜单范围过滤：tenant=仅租户可用菜单", + ), ) -> None: # 模糊查询字段 self.name = (QueueEnum.like.value, name) @@ -172,3 +254,6 @@ class MenuQueryParam: if menu_client in ("pc", "app"): self.client = (QueueEnum.eq.value, menu_client) + + if scope == "tenant": + self.scope = (QueueEnum.eq.value, "tenant") diff --git a/backend/app/api/v1/module_system/menu/service.py b/backend/app/api/v1/module_platform/menu/service.py similarity index 77% rename from backend/app/api/v1/module_system/menu/service.py rename to backend/app/api/v1/module_platform/menu/service.py index 441305c6..f49e9a61 100644 --- a/backend/app/api/v1/module_system/menu/service.py +++ b/backend/app/api/v1/module_platform/menu/service.py @@ -1,7 +1,6 @@ from typing import Any -from app.api.v1.module_system.auth.schema import AuthSchema -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable from app.core.exceptions import CustomException from app.utils.common_util import ( get_child_id_map, @@ -34,10 +33,12 @@ class MenuService: 无父级时仅允许目录、菜单、外链（与前端一致）。 """ if parent_id is None: + if child_type is None: + return if child_type not in (1, 2, 4): raise CustomException(msg="顶级菜单仅允许目录、菜单或外链类型") return - parent = await MenuCRUD(auth).get_by_id_crud(id=parent_id) + parent = await MenuCRUD(auth).get(id=parent_id) if not parent: raise CustomException(msg="父级菜单不存在") pt = parent.type @@ -55,9 +56,9 @@ class MenuService: cls, auth: AuthSchema, parent_id: int | None, client: str ) -> None: """子菜单终端须与父菜单一致。""" - if parent_id is None: + if parent_id is None or client is None: return - parent = await MenuCRUD(auth).get_by_id_crud(id=parent_id) + parent = await MenuCRUD(auth).get(id=parent_id) if not parent: return p_client = getattr(parent, "client", None) or "pc" @@ -65,7 +66,7 @@ class MenuService: raise CustomException(msg="子菜单终端须与父菜单一致（均为 pc 或均为 app）") @classmethod - async def get_menu_detail_service(cls, auth: AuthSchema, id: int) -> dict: + async def get_menu_detail_service(cls, auth: AuthSchema, id: int) -> MenuOutSchema: """ 获取菜单详情。 @@ -76,15 +77,15 @@ class MenuService: 返回: - dict: 菜单详情对象。 """ - menu = await MenuCRUD(auth).get_by_id_crud(id=id) + menu = await MenuCRUD(auth).get(id=id) # 创建实例后再设置parent_name属性 menu_out = MenuOutSchema.model_validate(menu) if menu and menu.parent_id: - parent = await MenuCRUD(auth).get_by_id_crud(id=menu.parent_id) + parent = await MenuCRUD(auth).get(id=menu.parent_id) if parent: menu_out.parent_name = parent.name - return menu_out.model_dump() + return menu_out @classmethod async def get_menu_tree_service( @@ -105,7 +106,7 @@ class MenuService: - list[dict]: 菜单树形列表对象。 """ # 使用树形结构查询，预加载children关系 - menu_list = await MenuCRUD(auth).get_tree_list_crud( + menu_list = await MenuCRUD(auth).get_tree_list( search=search.__dict__, order_by=order_by ) # 转换为字典列表 @@ -114,7 +115,7 @@ class MenuService: return traversal_to_tree(menu_dict_list) @classmethod - async def create_menu_service(cls, auth: AuthSchema, data: MenuCreateSchema) -> dict: + async def create_menu_service(cls, auth: AuthSchema, data: MenuCreateSchema) -> MenuOutSchema: """ 创建菜单。 @@ -125,22 +126,24 @@ class MenuService: 返回: - dict: 创建的菜单对象。 """ - search: dict[str, Any] = {"title": data.title} - if data.parent_id is not None: - search["parent_id"] = data.parent_id - menu = await MenuCRUD(auth).get(**search) - if menu: - raise CustomException(msg="创建失败，该菜单已存在") + search: dict[str, Any] = {} + if data.title is not None: + search["title"] = data.title + if data.parent_id is not None: + search["parent_id"] = data.parent_id + menu = await MenuCRUD(auth).get(**search) + if menu: + raise CustomException(msg="创建失败，该菜单已存在") await cls._validate_parent_child_type(auth, data.parent_id, data.type) await cls._validate_parent_child_client(auth, data.parent_id, data.client) new_menu = await MenuCRUD(auth).create(data=data) - new_menu_dict = MenuOutSchema.model_validate(new_menu).model_dump() + new_menu_dict = MenuOutSchema.model_validate(new_menu) return new_menu_dict @classmethod - async def update_menu_service(cls, auth: AuthSchema, id: int, data: MenuUpdateSchema) -> dict: + async def update_menu_service(cls, auth: AuthSchema, id: int, data: MenuUpdateSchema) -> MenuOutSchema: """ 更新菜单。 @@ -152,30 +155,31 @@ class MenuService: 返回: - dict: 更新的菜单对象。 """ - menu = await MenuCRUD(auth).get_by_id_crud(id=id) + menu = await MenuCRUD(auth).get(id=id) if not menu: raise CustomException(msg="更新失败，该菜单不存在") await cls._validate_parent_child_type(auth, data.parent_id, data.type) await cls._validate_parent_child_client(auth, data.parent_id, data.client) - search: dict[str, Any] = {"title": data.title} - if data.parent_id is not None: - search["parent_id"] = data.parent_id - exist_menu = await MenuCRUD(auth).get(**search) - if exist_menu and exist_menu.id != id: - raise CustomException(msg="更新失败，菜单标题重复") + if data.title is not None: + search: dict[str, Any] = {"title": data.title} + if data.parent_id is not None: + search["parent_id"] = data.parent_id + exist_menu = await MenuCRUD(auth).get(**search) + if exist_menu and exist_menu.id != id: + raise CustomException(msg="更新失败，菜单标题重复") if data.parent_id: - parent_menu = await MenuCRUD(auth).get_by_id_crud(id=data.parent_id) + parent_menu = await MenuCRUD(auth).get(id=data.parent_id) if not parent_menu: raise CustomException(msg="更新失败，父级菜单不存在") - data.parent_name = parent_menu.title new_menu = await MenuCRUD(auth).update(id=id, data=data) - await cls.set_menu_available_service( - auth=auth, data=BatchSetAvailable(ids=[id], status=data.status) - ) + if data.status is not None: + await cls.set_menu_available_service( + auth=auth, data=BatchSetAvailable(ids=[id], status=data.status) + ) - new_menu_dict = MenuOutSchema.model_validate(new_menu).model_dump() + new_menu_dict = MenuOutSchema.model_validate(new_menu) return new_menu_dict @classmethod @@ -194,7 +198,7 @@ class MenuService: raise CustomException(msg="删除失败，删除对象不能为空") # 获取所有菜单列表，用于构建树形关系 - all_menus = await MenuCRUD(auth).get_list_crud() + all_menus = await MenuCRUD(auth).list() # 构建子菜单ID映射 child_id_map = get_child_id_map(model_list=all_menus) @@ -225,10 +229,10 @@ class MenuService: 返回: - None """ - menu_list = await MenuCRUD(auth).get_list_crud() + menu_list = await MenuCRUD(auth).list() total_ids = [] - if data.status == "0": + if data.status == 0: # 激活，则需要把所有父级菜单都激活 id_map = get_parent_id_map(model_list=menu_list) for menu_id in data.ids: @@ -241,4 +245,4 @@ class MenuService: disable_ids = get_child_recursion(id=menu_id, id_map=id_map) total_ids.extend(disable_ids) - await MenuCRUD(auth).set_available_crud(ids=total_ids, status=data.status) + await MenuCRUD(auth).set(ids=total_ids, status=data.status) diff --git a/backend/app/api/v1/module_platform/order/__init__.py b/backend/app/api/v1/module_platform/order/__init__.py new file mode 100644 index 00000000..06039df3 --- /dev/null +++ b/backend/app/api/v1/module_platform/order/__init__.py @@ -0,0 +1,3 @@ +from .controller import OrderRouter, PaymentRouter, RefundRouter, TenantOrderRouter + +__all__ = ["OrderRouter", "PaymentRouter", "RefundRouter", "TenantOrderRouter"] diff --git a/backend/app/api/v1/module_platform/order/controller.py b/backend/app/api/v1/module_platform/order/controller.py new file mode 100644 index 00000000..6841c216 --- /dev/null +++ b/backend/app/api/v1/module_platform/order/controller.py @@ -0,0 +1,352 @@ +"""订单与支付 Controller""" +from typing import Annotated + +from fastapi import APIRouter, Body, Depends, Path, Query, Request +from fastapi.exceptions import HTTPException +from fastapi.responses import JSONResponse +from sqlalchemy.ext.asyncio import AsyncSession + +from app.common.response import ResponseSchema, SuccessResponse +from app.core.base_schema import AuthSchema, PageResultSchema +from app.core.dependencies import AuthPermission, db_getter +from app.core.exceptions import CustomException +from app.core.logger import logger +from app.core.router_class import OperationLogRoute + +from .schema import ( + OrderCreateSchema, + OrderOutSchema, + OrderQueryParam, + OrderStatusMessage, + PaymentCreateOut, + PaymentRecordOutSchema, + PaymentStatusOut, + RefundApplySchema, + RefundOutSchema, + RefundReviewSchema, +) +from .service import OrderService, PaymentService, RefundService + +OrderRouter = APIRouter(route_class=OperationLogRoute, prefix="/order", tags=["平台管理/订单管理"]) +PaymentRouter = APIRouter(route_class=OperationLogRoute, prefix="/payment", tags=["平台管理/支付管理"]) +RefundRouter = APIRouter(route_class=OperationLogRoute, prefix="/refund", tags=["平台管理/退款管理"]) +TenantOrderRouter = APIRouter(route_class=OperationLogRoute, prefix="/order", tags=["平台管理/租户订单"]) + + +def _make_bare_auth(db: AsyncSession) -> AuthSchema: + """构造无用户上下文的 AuthSchema（支付回调等场景）""" + return AuthSchema(db=db, check_data_scope=False) + + +# ─── 平台订单 ────────────────────────────────────────── + + +@OrderRouter.post("/create", summary="创建订单", response_model=ResponseSchema[OrderOutSchema]) +async def order_create( + data: Annotated[OrderCreateSchema, Body()], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:order:create']))], +) -> JSONResponse: + """ + 创建订单 + + 参数: + - data (OrderCreateSchema): 订单创建参数。 + + 返回: + - JSONResponse: 包含订单详情的 JSON 响应。 + """ + result = await OrderService.create_order(auth, data) + return SuccessResponse(data=result, msg="订单创建成功") + + +@OrderRouter.get("/detail/{order_id}", summary="订单详情", response_model=ResponseSchema[OrderOutSchema]) +async def order_detail( + order_id: Annotated[int, Path(ge=1)], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:order:query']))], +) -> JSONResponse: + """ + 订单详情 + + 参数: + - order_id (int): 订单 ID。 + + 返回: + - JSONResponse: 包含订单详情的 JSON 响应。 + """ + order = await OrderService.get_detail(auth, order_id) + if not order: + raise HTTPException(status_code=404, detail="订单不存在") + return SuccessResponse(data=order) + + +@OrderRouter.get("/list", summary="订单列表", response_model=ResponseSchema[PageResultSchema[OrderOutSchema]]) +async def order_list( + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:order:query']))], + tenant_id: Annotated[int | None, Query()] = None, + status: Annotated[int | None, Query()] = None, + order_type: Annotated[str | None, Query()] = None, + page: Annotated[int, Query(ge=1)] = 1, + page_size: Annotated[int, Query(ge=1, le=100)] = 20, +) -> JSONResponse: + """ + 订单列表 + + 参数: + - tenant_id (int | None): 租户 ID 筛选。 + - status (int | None): 状态筛选。 + - order_type (str | None): 订单类型筛选。 + - page (int): 页码。 + - page_size (int): 每页条数。 + + 返回: + - JSONResponse: 包含分页订单列表的 JSON 响应。 + """ + params = OrderQueryParam(tenant_id=tenant_id, status=status, order_type=order_type) + offset = (page - 1) * page_size + items, total = await OrderService.get_list(auth, params, offset, page_size) + result = PageResultSchema( + page_no=page, + page_size=page_size, + total=total, + has_next=offset + page_size < total, + items=items, + ) + return SuccessResponse(data=result) + + +@OrderRouter.post("/cancel/{order_id}", summary="取消订单", response_model=ResponseSchema[OrderStatusMessage]) +async def order_cancel( + order_id: Annotated[int, Path(ge=1)], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:order:update']))], +) -> JSONResponse: + """ + 取消订单 + + 参数: + - order_id (int): 订单 ID。 + + 返回: + - JSONResponse: 包含取消结果的 JSON 响应。 + """ + result = await OrderService.cancel_order(auth, order_id) + return SuccessResponse(data=result, msg=result["message"]) + +# ─── 支付 ────────────────────────────────────────────── + + +@PaymentRouter.post("/pay/{order_id}", summary="创建支付（获取支付 URL/二维码）", response_model=ResponseSchema[PaymentCreateOut]) +async def payment_create( + order_id: Annotated[int, Path(ge=1)], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:order:update']))], + request: Request, + method: Annotated[str, Query(description="支付渠道: alipay / wxpay(留空=自动)")] = "", +) -> JSONResponse: + """创建支付 + + 调用支付网关生成支付 URL（H5 跳转）或二维码（Native 扫码）。 + """ + base_url = str(request.base_url).rstrip("/") + result = await PaymentService.create_payment(auth, order_id, method, base_url) + return SuccessResponse(data=result, msg="支付信息已生成") + + +@PaymentRouter.get("/status/{order_id}", summary="查询支付状态（供前端轮询）", response_model=ResponseSchema[PaymentStatusOut]) +async def payment_status( + order_id: Annotated[int, Path(ge=1)], + db: Annotated[AsyncSession, Depends(db_getter)], +) -> JSONResponse: + """查询支付状态（无需登录，前端轮询用）""" + auth = _make_bare_auth(db) + result = await OrderService.check_payment_status(auth, order_id) + return SuccessResponse(data=result) + +# ─── 支付回调 ────────────────────────────────────────── + + +@PaymentRouter.post("/callback/{method}", summary="支付回调（统一入口）", response_model=ResponseSchema[dict]) +async def payment_callback( + method: Annotated[str, Path(description="支付渠道: alipay / wxpay / mock")], + data: Annotated[dict, Body()], + db: Annotated[AsyncSession, Depends(db_getter)], +) -> JSONResponse: + """接收支付网关的异步通知（无需认证）""" + try: + auth = _make_bare_auth(db) + result = await PaymentService.handle_callback(auth, method, data) + logger.info(f"支付回调处理成功: {result}") + return SuccessResponse(data=result) + except CustomException as e: + logger.warning(f"支付回调处理失败: {e}") + return SuccessResponse(data={"message": str(e)}, code=400) + + +@PaymentRouter.post("/mock/callback", summary="Mock 支付回调（开发环境触发模拟支付）", response_model=ResponseSchema[dict]) +async def payment_mock_callback( + order_id: Annotated[int, Body(ge=1, description="订单 ID")], + db: Annotated[AsyncSession, Depends(db_getter)], +) -> JSONResponse: + """开发环境下手动触发模拟支付成功回调""" + from app.core.payment import get_mock_gateway + + from .crud import OrderCRUD + + auth = _make_bare_auth(db) + order = await OrderCRUD(auth).get_by_id(order_id) + if not order: + raise HTTPException(status_code=404, detail="订单不存在") + + mock_gw = get_mock_gateway() + callback_data = mock_gw.get_mock_callback_data(order.id, order.order_no) + result = await PaymentService.handle_callback(auth, "mock", callback_data) + logger.info(f"Mock 支付回调触发: order_id={order_id}") + return SuccessResponse(data=result, msg="模拟支付成功") + +# ─── 支付记录 ────────────────────────────────────────── + + +@PaymentRouter.get("/record/list", summary="支付记录列表", response_model=ResponseSchema[PageResultSchema[PaymentRecordOutSchema]]) +async def payment_record_list( + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:order:query']))], + page: Annotated[int, Query(ge=1)] = 1, + page_size: Annotated[int, Query(ge=1, le=100)] = 20, +) -> JSONResponse: + """ + 支付记录列表 + + 参数: + - page (int): 页码。 + - page_size (int): 每页条数。 + + 返回: + - JSONResponse: 包含分页支付记录列表的 JSON 响应。 + """ + offset = (page - 1) * page_size + items, total = await PaymentService.get_records(auth, offset, page_size) + result = PageResultSchema( + page_no=page, + page_size=page_size, + total=total, + has_next=offset + page_size < total, + items=items, + ) + return SuccessResponse(data=result) + +# ─── 退款管理 ────────────────────────────────────────── + + +@RefundRouter.get("/list", summary="退款审核列表", response_model=ResponseSchema[PageResultSchema[RefundOutSchema]]) +async def refund_list( + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:order:query']))], + status: Annotated[int | None, Query(description="状态筛选")] = None, + page: Annotated[int, Query(ge=1)] = 1, + page_size: Annotated[int, Query(ge=1, le=100)] = 20, +) -> JSONResponse: + """ + 退款审核列表 + + 参数: + - status (int | None): 状态筛选。 + - page (int): 页码。 + - page_size (int): 每页条数。 + + 返回: + - JSONResponse: 包含分页退款列表的 JSON 响应。 + """ + offset = (page - 1) * page_size + items, total = await RefundService.get_list(auth, status, offset, page_size) + result = PageResultSchema( + page_no=page, + page_size=page_size, + total=total, + has_next=offset + page_size < total, + items=items, + ) + return SuccessResponse(data=result) + + +@RefundRouter.put("/approve/{refund_id}", summary="批准退款", response_model=ResponseSchema[OrderStatusMessage]) +async def refund_approve( + refund_id: Annotated[int, Path(ge=1)], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:order:update']))], +) -> JSONResponse: + """ + 批准退款 + + 参数: + - refund_id (int): 退款申请 ID。 + + 返回: + - JSONResponse: 包含批准结果的 JSON 响应。 + """ + result = await RefundService.approve( + auth, refund_id, + auth.user.id if auth.user else 0, + auth.user.name if auth.user else "", + ) + return SuccessResponse(data=result, msg=result["message"]) + + +@RefundRouter.put("/reject/{refund_id}", summary="驳回退款", response_model=ResponseSchema[OrderStatusMessage]) +async def refund_reject( + refund_id: Annotated[int, Path(ge=1)], + data: Annotated[RefundReviewSchema, Body()], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:order:update']))], +) -> JSONResponse: + """ + 驳回退款 + + 参数: + - refund_id (int): 退款申请 ID。 + - data (RefundReviewSchema): 驳回原因。 + + 返回: + - JSONResponse: 包含驳回结果的 JSON 响应。 + """ + result = await RefundService.reject( + auth, refund_id, + auth.user.id if auth.user else 0, data, + auth.user.name if auth.user else "", + ) + return SuccessResponse(data=result, msg=result["message"]) + +# ─── 租户端订单 ──────────────────────────────────────── + + +@TenantOrderRouter.post("/create", summary="租户端创建订单", response_model=ResponseSchema[OrderOutSchema]) +async def tenant_order_create( + data: Annotated[OrderCreateSchema, Body()], + auth: Annotated[AuthSchema, Depends(AuthPermission(['tenant:order:create']))], +) -> JSONResponse: + """ + 租户端创建订单 + + 参数: + - data (OrderCreateSchema): 订单创建参数。 + + 返回: + - JSONResponse: 包含订单详情的 JSON 响应。 + """ + if data.tenant_id != auth.tenant_id: + raise HTTPException(status_code=403, detail="无权操作") + result = await OrderService.create_order(auth, data) + return SuccessResponse(data=result, msg="订单创建成功") + + +@TenantOrderRouter.post("/refund/apply/{order_id}", summary="申请退款", response_model=ResponseSchema[RefundOutSchema]) +async def tenant_refund_apply( + order_id: Annotated[int, Path(ge=1)], + data: Annotated[RefundApplySchema, Body()], + auth: Annotated[AuthSchema, Depends(AuthPermission(['tenant:order:refund']))], +) -> JSONResponse: + """ + 租户端申请退款 + + 参数: + - order_id (int): 订单 ID。 + - data (RefundApplySchema): 退款申请参数。 + + 返回: + - JSONResponse: 包含退款申请结果的 JSON 响应。 + """ + result = await RefundService.apply(auth, data, order_id) + return SuccessResponse(data=result, msg="退款申请已提交") diff --git a/backend/app/api/v1/module_platform/order/crud.py b/backend/app/api/v1/module_platform/order/crud.py new file mode 100644 index 00000000..e16238f9 --- /dev/null +++ b/backend/app/api/v1/module_platform/order/crud.py @@ -0,0 +1,110 @@ +"""订单与支付 CRUD""" +from datetime import datetime +from typing import Any + +from app.core.base_crud import CRUDBase +from app.core.base_schema import AuthSchema + +from .model import OrderModel, PaymentRecordModel, RefundModel +from .schema import ( + OrderCreateInternalSchema, + OrderUpdateInternalSchema, + PaymentRecordCreateSchema, + RefundCreateSchema, + RefundUpdateSchema, +) + + +class OrderCRUD(CRUDBase[OrderModel, OrderCreateInternalSchema, OrderUpdateInternalSchema]): + """订单 CRUD""" + + def __init__(self, auth: AuthSchema) -> None: + super().__init__(model=OrderModel, auth=auth) + + async def get_by_order_no(self, order_no: str) -> OrderModel | None: + return await self.get(order_no=order_no) + + async def query( + self, + *, + tenant_id: int | None = None, + status: int | None = None, + order_type: str | None = None, + offset: int = 0, + limit: int = 20, + ) -> tuple[list[OrderModel], int]: + result = await self.page( + search={"tenant_id": tenant_id, "status": status, "order_type": order_type}, + order_by=[{"created_time": "desc"}], + offset=offset, + limit=limit, + ) + return result.items, result.total + + async def mark_refunded(self, order_id: int) -> None: + from sqlalchemy import update as sa_update + await self.db.execute( + sa_update(OrderModel) + .where(OrderModel.id == order_id) + .where(OrderModel.is_deleted == False) # noqa: E712 + .values(status=3) + ) + + @staticmethod + async def cancel_expired_orders() -> None: + """定时任务：取消超时未支付订单""" + from sqlalchemy import update as sa_update + + from app.core.database import async_db_session + from app.core.logger import logger + + now = datetime.now() + async with async_db_session() as session: + async with session.begin(): + result = await session.execute( + sa_update(OrderModel) + .where(OrderModel.status == 0) + .where(OrderModel.expire_time < now) + .where(OrderModel.is_deleted == False) # noqa: E712 + .values(status=2) + ) + logger.info(f"超时订单取消: 已取消 {result.rowcount} 条订单") + + +class PaymentRecordCRUD(CRUDBase[PaymentRecordModel, PaymentRecordCreateSchema, Any]): + """支付记录 CRUD""" + + def __init__(self, auth: AuthSchema) -> None: + super().__init__(model=PaymentRecordModel, auth=auth) + + async def query( + self, offset: int = 0, limit: int = 20 + ) -> tuple[list[PaymentRecordModel], int]: + result = await self.page( + order_by=[{"created_time": "desc"}], + offset=offset, + limit=limit, + search={}, + ) + return result.items, result.total + + +class RefundCRUD(CRUDBase[RefundModel, RefundCreateSchema, RefundUpdateSchema]): + """退款 CRUD""" + + def __init__(self, auth: AuthSchema) -> None: + super().__init__(model=RefundModel, auth=auth) + + async def get_by_order_id(self, order_id: int) -> RefundModel | None: + return await self.get(order_id=order_id) + + async def query( + self, status: int | None = None, offset: int = 0, limit: int = 20 + ) -> tuple[list[RefundModel], int]: + result = await self.page( + search={"status": status}, + order_by=[{"created_time": "desc"}], + offset=offset, + limit=limit, + ) + return result.items, result.total diff --git a/backend/app/api/v1/module_platform/order/model.py b/backend/app/api/v1/module_platform/order/model.py new file mode 100644 index 00000000..4d7fdcf5 --- /dev/null +++ b/backend/app/api/v1/module_platform/order/model.py @@ -0,0 +1,67 @@ +"""订单与支付 Model""" +from datetime import datetime + +from sqlalchemy import DateTime, ForeignKey, Integer, String, Text +from sqlalchemy.orm import Mapped, mapped_column + +from app.core.base_model import ModelMixin, TenantMixin + + +class OrderModel(ModelMixin, TenantMixin): + """platform_order — 订单表 + + 支持两种订单类型： + - 套餐订单：new/renew/upgrade/downgrade，package_id 必填 + - 插件订单：plugin，plugin_id 必填，package_id 为空 + + status: 0=待支付 1=已支付 2=已取消 3=已退款 + """ + + __tablename__ = "platform_order" + __table_args__: dict[str, str] = {"comment": "订单表"} + + order_no: Mapped[str] = mapped_column(String(32), nullable=False, unique=True, comment="订单号") + package_id: Mapped[int | None] = mapped_column(ForeignKey("platform_package.id"), nullable=True, comment="购买套餐(插件订单为空)") + plugin_id: Mapped[int | None] = mapped_column(ForeignKey("platform_plugin.id"), nullable=True, comment="购买插件(套餐订单为空)") + order_type: Mapped[str] = mapped_column(String(20), nullable=False, comment="new/renew/upgrade/downgrade/plugin") + amount: Mapped[int] = mapped_column(Integer, nullable=False, comment="金额(分)") + period_count: Mapped[int] = mapped_column(Integer, nullable=False, default=1, comment="购买周期数") + pay_method: Mapped[str | None] = mapped_column(String(20), nullable=True, comment="alipay/wxpay") + pay_time: Mapped[datetime | None] = mapped_column(DateTime, nullable=True, comment="支付时间") + expire_time: Mapped[datetime] = mapped_column(DateTime, nullable=False, comment="订单过期时间(15分钟)") + + +class PaymentRecordModel(ModelMixin, TenantMixin): + """platform_payment_record — 支付记录表 + + status: 0=处理中 1=成功 2=失败 + """ + + __tablename__ = "platform_payment_record" + __table_args__: dict[str, str] = {"comment": "支付记录表"} + + order_id: Mapped[int] = mapped_column(ForeignKey("platform_order.id"), nullable=False, comment="关联订单") + transaction_id: Mapped[str | None] = mapped_column(String(64), nullable=True, unique=True, comment="第三方交易号") + pay_method: Mapped[str] = mapped_column(String(20), nullable=False, comment="支付方式") + amount: Mapped[int] = mapped_column(Integer, nullable=False, comment="支付金额(分)") + raw_response: Mapped[str | None] = mapped_column(Text, nullable=True, comment="原始回调JSON") + pay_time: Mapped[datetime | None] = mapped_column(DateTime, nullable=True, comment="支付完成时间") + + +class RefundModel(ModelMixin, TenantMixin): + """platform_refund — 退款表 + + status: 1=申请中 2=已退款 3=已驳回 4=已取消 + """ + + __tablename__ = "platform_refund" + __table_args__: dict[str, str] = {"comment": "退款表"} + + order_id: Mapped[int] = mapped_column(ForeignKey("platform_order.id"), nullable=False, unique=True, comment="关联订单") + refund_no: Mapped[str] = mapped_column(String(32), nullable=False, unique=True, comment="退款单号") + amount: Mapped[int] = mapped_column(Integer, nullable=False, comment="退款金额(分)") + reason: Mapped[str] = mapped_column(Text, nullable=False, comment="退款原因") + refund_transaction_id: Mapped[str | None] = mapped_column(String(64), nullable=True, comment="退款交易号") + reviewer_id: Mapped[int | None] = mapped_column(ForeignKey("sys_user.id"), nullable=True, comment="审核人") + review_time: Mapped[datetime | None] = mapped_column(DateTime, nullable=True, comment="审核时间") + reject_reason: Mapped[str | None] = mapped_column(Text, nullable=True, comment="驳回原因") diff --git a/backend/app/api/v1/module_platform/order/schema.py b/backend/app/api/v1/module_platform/order/schema.py new file mode 100644 index 00000000..bdbb5b80 --- /dev/null +++ b/backend/app/api/v1/module_platform/order/schema.py @@ -0,0 +1,186 @@ +"""订单与支付 Schema""" +from __future__ import annotations + +from datetime import datetime + +from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator + +from app.core.base_schema import BaseSchema + +# ─── Internal Create/Update Schemas（CRUD 层用，字段映射 Model 1:1）─── + + +class OrderCreateInternalSchema(BaseModel): + """订单创建（内部 CRUD 用，包含所有业务字段）""" + order_no: str + tenant_id: int + package_id: int | None = None + plugin_id: int | None = None + order_type: str + amount: int + period_count: int = 1 + pay_method: str | None = None + pay_time: datetime | None = None + expire_time: datetime + status: int = 0 + + +class OrderUpdateInternalSchema(BaseModel): + """订单更新（内部 CRUD 用）""" + status: int | None = None + pay_method: str | None = None + pay_time: datetime | None = None + + +class PaymentRecordCreateSchema(BaseModel): + """支付记录创建""" + order_id: int + transaction_id: str | None = None + pay_method: str + amount: int + status: int = 1 + raw_response: str | None = None + pay_time: datetime | None = None + + +class RefundCreateSchema(BaseModel): + """退款记录创建""" + order_id: int + refund_no: str + amount: int + reason: str + status: int = 1 + + +class RefundUpdateSchema(BaseModel): + """退款记录更新""" + status: int | None = None + reviewer_id: int | None = None + review_time: datetime | None = None + reject_reason: str | None = None + + +# ─── Order ────────────────────────────────────────────── + + +class OrderCreateSchema(BaseModel): + """创建订单（套餐或插件）""" + tenant_id: int + package_id: int | None = Field(default=None, description="套餐ID（套餐订单必填）") + plugin_id: int | None = Field(default=None, description="插件ID（插件订单必填）") + order_type: str = Field(pattern=r"^(new|renew|upgrade|downgrade|plugin)$") + pay_method: str | None = Field(default=None, pattern=r"^(alipay|wxpay)?$") + + @field_validator("tenant_id") + @classmethod + def positive(cls, v: int) -> int: + if v <= 0: + raise ValueError("必须为正整数") + return v + + @model_validator(mode="after") + def check_target(self) -> OrderCreateSchema: + if self.order_type == "plugin": + if not self.plugin_id or self.plugin_id <= 0: + raise ValueError("插件订单必须指定 plugin_id") + else: + if not self.package_id or self.package_id <= 0: + raise ValueError("套餐订单必须指定 package_id") + return self + + +class OrderOutSchema(BaseSchema): + """订单输出""" + order_no: str + tenant_id: int + package_id: int | None = None + plugin_id: int | None = None + order_type: str + amount: int + period_count: int + pay_method: str | None = None + pay_time: datetime | None = None + expire_time: datetime + + model_config = ConfigDict(from_attributes=True) + + +class OrderQueryParam(BaseModel): + """订单查询参数""" + tenant_id: int | None = None + status: int | None = None + order_type: str | None = None + + +# ─── Payment ──────────────────────────────────────────── + +class PaymentCallbackSchema(BaseModel): + """支付回调数据""" + transaction_id: str | None = None + amount: int + order_id: int | None = None + raw_data: dict | None = None + + +class PaymentRecordOutSchema(BaseSchema): + """支付记录输出""" + order_id: int + transaction_id: str | None = None + pay_method: str + amount: int + pay_time: datetime | None = None + + model_config = ConfigDict(from_attributes=True) + + +class PaymentCreateOut(BaseModel): + """创建支付结果""" + pay_url: str + qr_code_url: str + trade_no: str + order_id: int + order_no: str + amount: int + + +class PaymentStatusOut(BaseModel): + """支付状态查询结果""" + exists: bool + order_id: int | None = None + status: int | None = None + paid: bool = False + pay_method: str | None = None + pay_time: str | None = None + + +class OrderStatusMessage(BaseModel): + """订单/退款操作结果消息""" + id: int + status: int + message: str + + +# ─── Refund ───────────────────────────────────────────── + +class RefundApplySchema(BaseModel): + """退款申请""" + reason: str = Field(min_length=1, max_length=500) + + +class RefundReviewSchema(BaseModel): + """退款审核""" + reject_reason: str | None = Field(default=None, max_length=500) + + +class RefundOutSchema(BaseSchema): + """退款记录输出""" + order_id: int + refund_no: str + amount: int + reason: str + refund_transaction_id: str | None = None + reviewer_id: int | None = None + review_time: datetime | None = None + reject_reason: str | None = None + + model_config = ConfigDict(from_attributes=True) diff --git a/backend/app/api/v1/module_platform/order/service.py b/backend/app/api/v1/module_platform/order/service.py new file mode 100644 index 00000000..11415fc2 --- /dev/null +++ b/backend/app/api/v1/module_platform/order/service.py @@ -0,0 +1,474 @@ +"""订单与支付 Service""" +import random +from datetime import datetime, timedelta + +from sqlalchemy import select + +from app.core.base_schema import AuthSchema +from app.core.exceptions import CustomException +from app.core.logger import logger +from app.core.payment import create_payment_gateway + +from .crud import OrderCRUD, PaymentRecordCRUD, RefundCRUD +from .model import OrderModel +from .schema import ( + OrderCreateInternalSchema, + OrderCreateSchema, + OrderOutSchema, + OrderQueryParam, + OrderStatusMessage, + OrderUpdateInternalSchema, + PaymentCreateOut, + PaymentRecordCreateSchema, + PaymentRecordOutSchema, + PaymentStatusOut, + RefundApplySchema, + RefundCreateSchema, + RefundOutSchema, + RefundReviewSchema, + RefundUpdateSchema, +) + + +def _generate_order_no() -> str: + """生成订单号：YYYYMMDD + 6位随机数""" + today = datetime.now().strftime("%Y%m%d") + suffix = str(random.randint(100000, 999999)) + return f"{today}{suffix}" + + +def _generate_refund_no() -> str: + """生成退款单号""" + today = datetime.now().strftime("%Y%m%d") + suffix = str(random.randint(100000, 999999)) + return f"RF{today}{suffix}" + + +class OrderService: + + @staticmethod + async def create_order(auth: AuthSchema, data: OrderCreateSchema, amount: int | None = None) -> OrderOutSchema: + """创建订单 + + 套餐订单：amount 从套餐价格自动计算 + 插件订单：amount 从插件价格自动计算 + """ + if amount is None: + if data.order_type == "plugin": + from app.api.v1.module_platform.plugin.model import PluginModel + plugin = await auth.db.get(PluginModel, data.plugin_id) + amount = plugin.price if plugin and hasattr(plugin, "price") else 0 + else: + from app.api.v1.module_platform.package.model import PackageModel + pkg = await auth.db.get(PackageModel, data.package_id) + amount = pkg.price if pkg and hasattr(pkg, "price") else 0 + + order = await OrderCRUD(auth).create( + OrderCreateInternalSchema( + order_no=_generate_order_no(), + tenant_id=data.tenant_id, + package_id=data.package_id, + plugin_id=data.plugin_id, + order_type=data.order_type, + amount=amount, + expire_time=datetime.now() + timedelta(minutes=15), + ) + ) + + # 免费订单自动激活 + if amount == 0: + await OrderCRUD(auth).update( + order.id, + OrderUpdateInternalSchema(status=1, pay_method="free", pay_time=datetime.now()), + ) + await PaymentService._activate_tenant_package(auth, order) + await auth.db.refresh(order) + + return OrderOutSchema.model_validate(order) + + @staticmethod + async def get_detail(auth: AuthSchema, order_id: int) -> OrderOutSchema | None: + order = await OrderCRUD(auth).get_by_id(order_id) + return OrderOutSchema.model_validate(order) if order else None + + @staticmethod + async def get_list( + auth: AuthSchema, params: OrderQueryParam, offset: int, limit: int + ) -> tuple[list, int]: + rows, total = await OrderCRUD(auth).query( + tenant_id=params.tenant_id, status=params.status, + order_type=params.order_type, offset=offset, limit=limit, + ) + items = [OrderOutSchema.model_validate(r) for r in rows] + return items, total + + @staticmethod + async def cancel_order(auth: AuthSchema, order_id: int) -> OrderStatusMessage: + crud = OrderCRUD(auth) + order = await crud.get_by_id(order_id) + if not order: + raise CustomException(msg="订单不存在") + if order.status != 0: + raise CustomException(msg="仅待支付订单可取消") + await crud.update(order_id, OrderUpdateInternalSchema(status=2)) + return OrderStatusMessage(id=order.id, status=2, message="已取消") + + @staticmethod + async def check_payment_status(auth: AuthSchema, order_id: int) -> PaymentStatusOut: + """查询订单支付状态（供前端轮询用）""" + order = await OrderCRUD(auth).get_by_id(order_id) + if not order: + return PaymentStatusOut(exists=False) + return PaymentStatusOut( + exists=True, + order_id=order.id, + status=order.status, + paid=order.status == 1, + pay_method=order.pay_method, + pay_time=order.pay_time.isoformat() if order.pay_time else None, + ) + + @staticmethod + async def cancel_expired_orders() -> None: + """定时任务：取消超时未支付的订单""" + await OrderCRUD.cancel_expired_orders() + + +class PaymentService: + + @staticmethod + async def create_payment( + auth: AuthSchema, order_id: int, method: str, notify_base_url: str + ) -> PaymentCreateOut: + """创建支付（调用支付网关）""" + from app.api.v1.module_platform.package.model import PackageModel + + order = await OrderCRUD(auth).get_by_id(order_id) + if not order: + raise CustomException(msg="订单不存在") + if order.status != 0: + raise CustomException(msg="订单状态异常，无法支付") + if order.amount <= 0: + raise CustomException(msg="免费订单无需支付") + + if order.order_type == "plugin": + from app.api.v1.module_platform.plugin.model import PluginModel + plugin = await auth.db.get(PluginModel, order.plugin_id) + subject = f"FastapiAdmin - 插件 {plugin.name}" if plugin else "FastapiAdmin 插件" + else: + pkg = await auth.db.get(PackageModel, order.package_id) + subject = f"FastapiAdmin - {pkg.name}" if pkg else "FastapiAdmin 套餐" + + notify_url = f"{notify_base_url}/api/v1/platform/payment/callback/{method}" if method else "" + + gateway = create_payment_gateway(method) + info = await gateway.create_payment( + order_no=order.order_no, + amount=order.amount, + subject=subject, + notify_url=notify_url, + ) + return PaymentCreateOut( + pay_url=info.pay_url, + qr_code_url=info.qr_code_url, + trade_no=info.trade_no, + order_id=order.id, + order_no=order.order_no, + amount=order.amount, + ) + + @staticmethod + async def handle_callback( + auth: AuthSchema, method: str, callback_data: dict + ) -> dict: + """处理支付回调""" + gateway = create_payment_gateway(method) + callback_result = await gateway.verify_callback(callback_data) + + if not callback_result.verified: + logger.warning(f"支付回调验签失败: method={method} data={callback_data}") + raise CustomException(msg="支付回调验签失败") + + order_no = callback_data.get("order_no") or callback_data.get("out_trade_no", "") + o_crud = OrderCRUD(auth) + order = None + if order_no: + order = await o_crud.get_by_order_no(order_no) + elif callback_result.order_id: + order = await o_crud.get_by_id(callback_result.order_id) + + if not order: + raise CustomException(msg="订单不存在") + if order.status != 0: + raise CustomException(msg="订单状态异常") + if order.amount != callback_result.amount and callback_result.amount > 0: + raise CustomException(msg="金额不一致") + + pid = order.package_id + tid = order.tenant_id + otype = order.order_type + oid = order.id + + await o_crud.update( + oid, + OrderUpdateInternalSchema(status=1, pay_method=method, pay_time=datetime.now()), + ) + + await PaymentRecordCRUD(auth).create( + PaymentRecordCreateSchema( + order_id=oid, + transaction_id=callback_result.transaction_id, + pay_method=method, + amount=callback_result.amount, + raw_response=str(callback_result.raw) if callback_result.raw else None, + pay_time=datetime.now(), + ) + ) + + order.package_id = pid + order.tenant_id = tid + order.order_type = otype + await PaymentService._activate_tenant_package(auth, order) + + logger.info( + f"支付回调处理完成: order_id={oid} method={method} " + f"tenant_id={tid} type={otype}" + ) + return {"order_id": oid, "status": 1, "message": "支付成功"} + + @staticmethod + async def _activate_tenant_package(auth: AuthSchema, order: OrderModel) -> None: + """支付成功后激活套餐/插件""" + from app.api.v1.module_platform.package.model import PackageModel + from app.api.v1.module_platform.tenant.model import TenantModel + + if order.order_type == "plugin": + await PaymentService._activate_plugin(auth, order) + return + + pkg = await auth.db.get(PackageModel, order.package_id) + if not pkg: + logger.warning(f"支付回调：套餐 {order.package_id} 不存在，跳过激活") + return + + tenant = await auth.db.get(TenantModel, order.tenant_id) + if not tenant: + logger.warning(f"支付回调：租户 {order.tenant_id} 不存在，跳过激活") + return + + now = datetime.now() + period_months = order.period_count or 1 + duration = timedelta(days=30 * period_months) + + if order.order_type == "new": + tenant.package_id = order.package_id + tenant.start_time = now + tenant.end_time = now + duration + tenant.status = 0 + logger.info(f"租户[{tenant.name}]新开通 {pkg.name}，有效期至 {tenant.end_time}") + + elif order.order_type == "renew": + base = tenant.end_time if tenant.end_time and tenant.end_time > now else now + tenant.end_time = base + duration + tenant.status = 0 + logger.info(f"租户[{tenant.name}]续费 {pkg.name}，续至 {tenant.end_time}") + + elif order.order_type in ("upgrade", "downgrade"): + if order.order_type == "downgrade": + await PaymentService._check_downgrade_quota(auth, order.tenant_id, pkg) + tenant.package_id = order.package_id + tenant.status = 0 + logger.info(f"租户[{tenant.name}]套餐变更 {'升级' if order.order_type == 'upgrade' else '降级'} → {pkg.name}") + + await auth.db.flush() + + if tenant.contact_email: + await PaymentService._send_order_email(order, pkg, tenant) + + @staticmethod + async def _activate_plugin(auth: AuthSchema, order: OrderModel) -> None: + """支付成功后标记插件为已购买""" + from app.api.v1.module_platform.plugin.model import PluginModel, TenantPluginModel + + plugin = await auth.db.get(PluginModel, order.plugin_id) + if not plugin: + logger.warning(f"支付回调：插件 {order.plugin_id} 不存在") + return + + result = await auth.db.execute( + select(TenantPluginModel).where( + TenantPluginModel.tenant_id == order.tenant_id, + TenantPluginModel.plugin_id == order.plugin_id, + ).limit(1) + ) + existing = result.scalar_one_or_none() + if existing: + existing.purchased = "1" + else: + tp = TenantPluginModel( + tenant_id=order.tenant_id, + plugin_id=order.plugin_id, + purchased="1", + enabled="0", + installed_time=datetime.now(), + ) + auth.db.add(tp) + + await auth.db.flush() + logger.info(f"租户[{order.tenant_id}]已购买插件[{plugin.name}]") + + from app.api.v1.module_platform.tenant.model import TenantModel + tenant = await auth.db.get(TenantModel, order.tenant_id) + if tenant and tenant.contact_email: + await PaymentService._send_order_email(order, plugin, tenant, order_type_label="购买") + + @staticmethod + async def _check_downgrade_quota( + auth: AuthSchema, tenant_id: int, new_pkg: object + ) -> None: + """降级前检查：租户当前资源数是否超过新套餐限额""" + from sqlalchemy import func, select + + from app.api.v1.module_system.dept.model import DeptModel + from app.api.v1.module_system.role.model import RoleModel + from app.api.v1.module_system.user.model import UserModel + + checks = { + "用户": (UserModel, new_pkg.max_users), + "角色": (RoleModel, new_pkg.max_roles), + "部门": (DeptModel, new_pkg.max_depts), + } + + for label, (model, limit) in checks.items(): + if limit <= 0: + continue + count_stmt = select(func.count()).select_from(model).where( + model.tenant_id == tenant_id, + model.is_deleted.is_(False), + ) + result = await auth.db.execute(count_stmt) + current = result.scalar() or 0 + if current > limit: + raise CustomException( + msg=f"降级失败：当前租户已有 {current} 个{label}，超过目标套餐限额 {limit}" + ) + + @staticmethod + async def _send_order_email( + order: "OrderModel", product: object, tenant: object, order_type_label: str = "" + ) -> None: + """发送购买确认邮件（失败静默降级）""" + try: + from app.api.v1.module_platform.email.service import EmailSendService + + if not order_type_label: + order_type_labels = { + "new": "开通", + "renew": "续费", + "upgrade": "升级", + "downgrade": "降级", + "plugin": "购买", + } + order_type_label = order_type_labels.get(order.order_type, order.order_type) + + product_name = getattr(product, "name", "") if product else "" + amount_str = f"{order.amount / 100:.2f}" if order.amount else "0.00" + + await EmailSendService.send_by_template( + to_email=tenant.contact_email, + to_name=tenant.contact_name or tenant.name, + template_code="order_confirmation", + variables={ + "tenant_name": tenant.name, + "order_no": order.order_no, + "package_name": product_name, + "order_type": order_type_label, + "amount": amount_str, + }, + biz_type="order", + tenant_id=tenant.id, + ) + except Exception: + pass # 邮件发送失败不阻塞业务流程 + + @staticmethod + async def get_records( + auth: AuthSchema, offset: int, limit: int + ) -> tuple[list, int]: + rows, total = await PaymentRecordCRUD(auth).query(offset, limit) + items = [PaymentRecordOutSchema.model_validate(r) for r in rows] + return items, total + + +class RefundService: + + @staticmethod + async def apply(auth: AuthSchema, data: RefundApplySchema, order_id: int) -> RefundOutSchema: + o_crud = OrderCRUD(auth) + order = await o_crud.get_by_id(order_id) + if not order: + raise CustomException(msg="订单不存在") + if order.status != 1: + raise CustomException(msg="仅已支付订单可退款") + if order.amount == 0: + raise CustomException(msg="免费套餐不支持退款") + if order.pay_time and (datetime.now() - order.pay_time).days > 7: + raise CustomException(msg="已超过 7 天退款时限") + existing = await RefundCRUD(auth).get_by_order_id(order_id) + if existing: + raise CustomException(msg="已存在退款申请") + refund = await RefundCRUD(auth).create( + RefundCreateSchema( + order_id=order.id, + refund_no=_generate_refund_no(), + amount=order.amount, + reason=data.reason, + ) + ) + return RefundOutSchema.model_validate(refund) + + @staticmethod + async def get_list( + auth: AuthSchema, status: int | None, offset: int, limit: int + ) -> tuple[list, int]: + rows, total = await RefundCRUD(auth).query(status, offset, limit) + items = [RefundOutSchema.model_validate(r) for r in rows] + return items, total + + @staticmethod + async def approve(auth: AuthSchema, refund_id: int, reviewer_id: int, + operator_name: str = "") -> OrderStatusMessage: + crud = RefundCRUD(auth) + refund = await crud.get_by_id(refund_id) + if not refund: + raise CustomException(msg="退款记录不存在") + if refund.status != 1: + raise CustomException(msg="仅申请中可审核") + await crud.update( + refund_id, + RefundUpdateSchema(status=2, reviewer_id=reviewer_id, review_time=datetime.now()), + ) + await OrderCRUD(auth).mark_refunded(refund.order_id) + return OrderStatusMessage(id=refund.id, status=2, message="已批准退款") + + @staticmethod + async def reject( + auth: AuthSchema, refund_id: int, reviewer_id: int, + data: RefundReviewSchema, operator_name: str = "", + ) -> OrderStatusMessage: + crud = RefundCRUD(auth) + refund = await crud.get_by_id(refund_id) + if not refund: + raise CustomException(msg="退款记录不存在") + if refund.status != 1: + raise CustomException(msg="仅申请中可审核") + await crud.update( + refund_id, + RefundUpdateSchema( + status=3, + reviewer_id=reviewer_id, + review_time=datetime.now(), + reject_reason=data.reject_reason, + ), + ) + return OrderStatusMessage(id=refund.id, status=3, message="已驳回") diff --git a/backend/app/api/v1/module_platform/package/__init__.py b/backend/app/api/v1/module_platform/package/__init__.py new file mode 100644 index 00000000..b15115ed --- /dev/null +++ b/backend/app/api/v1/module_platform/package/__init__.py @@ -0,0 +1,3 @@ +from .controller import PackageRouter + +__all__ = ["PackageRouter"] diff --git a/backend/app/api/v1/module_platform/package/controller.py b/backend/app/api/v1/module_platform/package/controller.py index 482782e3..b7c4b091 100644 --- a/backend/app/api/v1/module_platform/package/controller.py +++ b/backend/app/api/v1/module_platform/package/controller.py @@ -2,53 +2,73 @@ from typing import Annotated from fastapi import APIRouter, Body, Depends, Path from fastapi.responses import JSONResponse +from fastapi_cache import FastAPICache +from fastapi_cache.decorator import cache -from app.api.v1.module_system.auth.schema import AuthSchema from app.common.response import ResponseSchema, SuccessResponse from app.core.base_params import PaginationQueryParam -from app.core.base_schema import BatchDelete, BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable, PageResultSchema from app.core.dependencies import AuthPermission -from app.core.logger import log from app.core.router_class import OperationLogRoute from .schema import ( PackageCreateSchema, PackageMenuSetSchema, PackageOutSchema, + PackagePluginSetSchema, PackageQueryParam, PackageUpdateSchema, ) from .service import PackageService -PackageRouter = APIRouter(route_class=OperationLogRoute, prefix="/package", tags=["套餐管理"]) +PackageRouter = APIRouter(route_class=OperationLogRoute, prefix="/package", tags=["平台管理/套餐管理"]) + +_PKG_NS = "package" @PackageRouter.get( "/detail/{id}", summary="获取套餐详情", - description="根据套餐ID获取套餐详情", response_model=ResponseSchema[PackageOutSchema], ) +@cache(expire=300, namespace=_PKG_NS) async def get_obj_detail_controller( id: Annotated[int, Path(description="套餐ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_package:package:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_package:package:query']))], ) -> JSONResponse: + """ + 获取套餐详情 + + 参数: + - id (int): 套餐 ID。 + + 返回: + - JSONResponse: 包含套餐详情的 JSON 响应。 + """ result_dict = await PackageService.detail_service(auth=auth, id=id) - log.info(f"获取套餐详情成功 {id}") return SuccessResponse(data=result_dict, msg="获取套餐详情成功") @PackageRouter.get( "/list", summary="获取套餐列表", - description="分页获取套餐列表", - response_model=ResponseSchema[dict], + response_model=ResponseSchema[PageResultSchema[PackageOutSchema]], ) async def get_obj_list_controller( page: Annotated[PaginationQueryParam, Depends()], search: Annotated[PackageQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_package:package:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_package:package:query']))], ) -> JSONResponse: + """ + 获取套餐列表 + + 参数: + - page (PaginationQueryParam): 分页查询参数。 + - search (PackageQueryParam): 查询筛选参数。 + + 返回: + - JSONResponse: 包含分页套餐列表的 JSON 响应。 + """ result_dict = await PackageService.page_service( auth=auth, page_no=page.page_no, @@ -62,75 +82,116 @@ async def get_obj_list_controller( @PackageRouter.post( "/create", summary="创建套餐", - description="创建新的租户套餐", response_model=ResponseSchema[PackageOutSchema], ) async def create_obj_controller( data: Annotated[PackageCreateSchema, Body(description="套餐信息")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_package:package:create"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_package:package:create']))], ) -> JSONResponse: + """ + 创建套餐 + + 参数: + - data (PackageCreateSchema): 套餐创建参数。 + + 返回: + - JSONResponse: 包含创建后的套餐详情的 JSON 响应。 + """ result_dict = await PackageService.create_service(auth=auth, data=data) - log.info(f"创建套餐成功 {result_dict.get('name')}") + await FastAPICache.clear(namespace=_PKG_NS) return SuccessResponse(data=result_dict, msg="创建成功") @PackageRouter.put( "/update/{id}", summary="更新套餐", - description="更新套餐信息", response_model=ResponseSchema[PackageOutSchema], ) async def update_obj_controller( id: Annotated[int, Path(description="套餐ID")], data: Annotated[PackageUpdateSchema, Body(description="套餐信息")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_package:package:update"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_package:package:update']))], ) -> JSONResponse: + """ + 更新套餐 + + 参数: + - id (int): 套餐 ID。 + - data (PackageUpdateSchema): 套餐更新参数。 + + 返回: + - JSONResponse: 包含更新后的套餐详情的 JSON 响应。 + """ result_dict = await PackageService.update_service(auth=auth, id=id, data=data) - log.info(f"更新套餐成功 {id}") + await FastAPICache.clear(namespace=_PKG_NS) return SuccessResponse(data=result_dict, msg="更新成功") @PackageRouter.delete( "/delete", summary="删除套餐", - description="批量删除套餐（已被租户使用的套餐无法删除）", response_model=ResponseSchema, ) async def delete_obj_controller( - data: Annotated[BatchDelete, Body(description="删除信息")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_package:package:delete"]))], + ids: Annotated[list[int], Body(description="ID列表")], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_package:package:delete']))], ) -> JSONResponse: - await PackageService.delete_service(auth=auth, ids=data.ids) - log.info(f"删除套餐成功 {data.ids}") + """ + 删除套餐 + + 参数: + - ids (list[int]): 套餐 ID 列表。 + + 返回: + - JSONResponse: 删除结果。 + """ + await PackageService.delete_service(auth=auth, ids=ids) + await FastAPICache.clear(namespace=_PKG_NS) return SuccessResponse(msg="删除成功") @PackageRouter.patch( "/status/batch", summary="批量修改状态", - description="批量启用/禁用套餐", response_model=ResponseSchema, ) async def set_available_controller( data: Annotated[BatchSetAvailable, Body(description="状态设置")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_package:package:update"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_package:package:update']))], ) -> JSONResponse: + """ + 批量修改套餐状态 + + 参数: + - data (BatchSetAvailable): 批量状态设置参数。 + + 返回: + - JSONResponse: 操作结果。 + """ for id in data.ids: await PackageService.update_service(auth=auth, id=id, data=PackageUpdateSchema(status=data.status)) - log.info(f"套餐状态设置成功 {data.ids}") + await FastAPICache.clear(namespace=_PKG_NS) return SuccessResponse(msg="状态设置成功") @PackageRouter.get( "/menus/{package_id}", summary="获取套餐菜单", - description="获取套餐包含的菜单ID列表", response_model=ResponseSchema[list[int]], ) async def get_menus_controller( package_id: Annotated[int, Path(description="套餐ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_package:package:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_package:package:query']))], ) -> JSONResponse: + """ + 获取套餐关联菜单 + + 参数: + - package_id (int): 套餐 ID。 + + 返回: + - JSONResponse: 包含菜单 ID 列表的 JSON 响应。 + """ result = await PackageService.get_menus_service(auth=auth, package_id=package_id) return SuccessResponse(data=result, msg="获取成功") @@ -138,14 +199,68 @@ async def get_menus_controller( @PackageRouter.post( "/menus/{package_id}/set", summary="设置套餐菜单", - description="批量设置套餐包含的菜单（先清空再写入）", response_model=ResponseSchema, ) async def set_menus_controller( package_id: Annotated[int, Path(description="套餐ID")], data: Annotated[PackageMenuSetSchema, Body(description="菜单列表")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_package:package:update"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_package:package:update']))], ) -> JSONResponse: + """ + 设置套餐菜单权限 + + 参数: + - package_id (int): 套餐 ID。 + - data (PackageMenuSetSchema): 菜单 ID 列表。 + + 返回: + - JSONResponse: 操作结果。 + """ await PackageService.set_menus_service(auth=auth, package_id=package_id, data=data) - log.info(f"套餐[{package_id}]菜单权限已设置, count={len(data.menu_ids)}") + return SuccessResponse(msg="设置成功") + + +@PackageRouter.get( + "/plugins/{package_id}", + summary="获取套餐插件", + response_model=ResponseSchema[list[int]], +) +async def get_plugins_controller( + package_id: Annotated[int, Path(description="套餐ID")], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_package:package:query']))], +) -> JSONResponse: + """ + 获取套餐关联插件 + + 参数: + - package_id (int): 套餐 ID。 + + 返回: + - JSONResponse: 包含插件 ID 列表的 JSON 响应。 + """ + result = await PackageService.get_plugins_service(auth=auth, package_id=package_id) + return SuccessResponse(data=result, msg="获取成功") + + +@PackageRouter.post( + "/plugins/{package_id}/set", + summary="设置套餐插件", + response_model=ResponseSchema, +) +async def set_plugins_controller( + package_id: Annotated[int, Path(description="套餐ID")], + data: Annotated[PackagePluginSetSchema, Body(description="插件列表")], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_package:package:update']))], +) -> JSONResponse: + """ + 设置套餐插件 + + 参数: + - package_id (int): 套餐 ID。 + - data (PackagePluginSetSchema): 插件 ID 列表。 + + 返回: + - JSONResponse: 操作结果。 + """ + await PackageService.set_plugins_service(auth=auth, package_id=package_id, data=data) return SuccessResponse(msg="设置成功") diff --git a/backend/app/api/v1/module_platform/package/crud.py b/backend/app/api/v1/module_platform/package/crud.py index 6b4d83c7..4c9b12bc 100644 --- a/backend/app/api/v1/module_platform/package/crud.py +++ b/backend/app/api/v1/module_platform/package/crud.py @@ -1,11 +1,12 @@ -from app.api.v1.module_system.auth.schema import AuthSchema from app.core.base_crud import CRUDBase +from app.core.base_schema import AuthSchema from .model import PackageModel +from .schema import PackageCreateSchema, PackageUpdateSchema -class PackageCRUD(CRUDBase): +class PackageCRUD(CRUDBase[PackageModel, PackageCreateSchema, PackageUpdateSchema]): """套餐模块 CRUD""" def __init__(self, auth: AuthSchema): - super().__init__(PackageModel, auth) + super().__init__(model=PackageModel, auth=auth) diff --git a/backend/app/api/v1/module_platform/package/model.py b/backend/app/api/v1/module_platform/package/model.py index a22e21ca..83049753 100644 --- a/backend/app/api/v1/module_platform/package/model.py +++ b/backend/app/api/v1/module_platform/package/model.py @@ -1,34 +1,34 @@ -from datetime import datetime - -from sqlalchemy import DateTime, ForeignKey, Integer, String, UniqueConstraint +from sqlalchemy import ForeignKey, Integer, String, UniqueConstraint from sqlalchemy.orm import Mapped, mapped_column, validates -from app.core.base_model import MappedBase +from app.core.base_model import MappedBase, ModelMixin -class PackageModel(MappedBase): +class PackageModel(ModelMixin): """ 套餐模型 - 定义租户可用的功能套餐 + + status: 0=正常 1=禁用 """ __tablename__: str = "platform_package" __table_args__: dict[str, str] = {"comment": "租户套餐表"} - id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True, comment="主键ID") name: Mapped[str] = mapped_column(String(100), nullable=False, unique=True, comment="套餐名称") code: Mapped[str] = mapped_column(String(100), nullable=False, unique=True, comment="套餐编码") - status: Mapped[str] = mapped_column( - String(10), nullable=False, default="0", comment="状态(0:正常 1:禁用)" - ) sort: Mapped[int] = mapped_column(Integer, nullable=False, default=0, comment="排序") - description: Mapped[str | None] = mapped_column( - String(255), nullable=True, default=None, comment="描述" - ) - create_time: Mapped[datetime] = mapped_column( - DateTime, default=datetime.now, nullable=False, comment="创建时间" - ) - update_time: Mapped[datetime] = mapped_column( - DateTime, default=datetime.now, onupdate=datetime.now, nullable=False, comment="更新时间" + # ─── 定价与计费 ─── + price: Mapped[int] = mapped_column(Integer, nullable=False, default=0, comment="价格(分)") + period: Mapped[str] = mapped_column(String(10), nullable=False, default="month", comment="计费周期(month/year)") + trial_days: Mapped[int] = mapped_column(Integer, nullable=False, default=0, comment="免费试用天数") + # ─── 配额限制 ─── + max_users: Mapped[int] = mapped_column(Integer, nullable=False, default=10, comment="最大用户数") + max_roles: Mapped[int] = mapped_column(Integer, nullable=False, default=5, comment="最大角色数") + max_depts: Mapped[int] = mapped_column(Integer, nullable=False, default=10, comment="最大部门数") + max_storage_mb: Mapped[int] = mapped_column(Integer, nullable=False, default=1024, comment="最大存储(MB)") + # ─── 速率限制 ─── + rate_limit: Mapped[int] = mapped_column( + Integer, nullable=False, default=60, comment="API速率限制(请求/10秒)" ) @validates("name") @@ -67,8 +67,36 @@ class PackageMenuModel(MappedBase): ) menu_id: Mapped[int] = mapped_column( Integer, - ForeignKey("sys_menu.id", ondelete="CASCADE", onupdate="CASCADE"), + ForeignKey("platform_menu.id", ondelete="CASCADE", onupdate="CASCADE"), nullable=False, index=True, comment="菜单ID", ) + + +class PackagePluginModel(MappedBase): + """ + 套餐-插件关联表 — 定义套餐包含的插件资源 + """ + + __tablename__: str = "platform_package_plugin" + __table_args__ = ( + UniqueConstraint("package_id", "plugin_id", name="uq_package_plugin"), + {"comment": "套餐插件关联表"}, + ) + + id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True, comment="主键ID") + package_id: Mapped[int] = mapped_column( + Integer, + ForeignKey("platform_package.id", ondelete="CASCADE", onupdate="CASCADE"), + nullable=False, + index=True, + comment="套餐ID", + ) + plugin_id: Mapped[int] = mapped_column( + Integer, + ForeignKey("platform_plugin.id", ondelete="CASCADE", onupdate="CASCADE"), + nullable=False, + index=True, + comment="插件ID", + ) diff --git a/backend/app/api/v1/module_platform/package/schema.py b/backend/app/api/v1/module_platform/package/schema.py index becb7eed..d11979aa 100644 --- a/backend/app/api/v1/module_platform/package/schema.py +++ b/backend/app/api/v1/module_platform/package/schema.py @@ -1,3 +1,5 @@ +from dataclasses import dataclass + from fastapi import Query from pydantic import BaseModel, ConfigDict, Field, field_validator @@ -10,9 +12,17 @@ class PackageCreateSchema(BaseModel): name: str = Field(..., min_length=1, max_length=100, description="套餐名称") code: str = Field(..., min_length=2, max_length=100, description="套餐编码") - status: str = Field(default="0", max_length=1, description="状态(0:正常 1:禁用)") + status: int = Field(default=0, ge=0, le=1, description="状态(0:正常 1:禁用)") sort: int = Field(default=0, ge=0, description="排序") description: str | None = Field(default=None, max_length=255, description="描述") + price: int = Field(default=0, ge=0, description="价格(分)") + period: str = Field(default="month", pattern=r"^(month|year)$", description="计费周期") + trial_days: int = Field(default=0, ge=0, description="免费试用天数") + max_users: int = Field(default=10, ge=0, description="最大用户数") + max_roles: int = Field(default=5, ge=0, description="最大角色数") + max_depts: int = Field(default=10, ge=0, description="最大部门数") + max_storage_mb: int = Field(default=1024, ge=0, description="最大存储(MB)") + rate_limit: int = Field(default=60, ge=10, description="API速率限制(请求/10秒)") @field_validator("name") @classmethod @@ -34,20 +44,28 @@ class PackageCreateSchema(BaseModel): @field_validator("status") @classmethod - def _validate_status(cls, v: str) -> str: - if v not in {"0", "1"}: + def _validate_status(cls, v: int) -> int: + if v not in {0, 1}: raise ValueError("状态仅支持 0(正常) 或 1(禁用)") return v -class PackageUpdateSchema(BaseModel): +class PackageUpdateSchema(PackageCreateSchema): """更新套餐""" - name: str | None = Field(default=None, max_length=100, description="套餐名称") - code: str | None = Field(default=None, max_length=100, description="套餐编码") - status: str | None = Field(default=None, max_length=1, description="状态(0:正常 1:禁用)") + name: str | None = Field(default=None, max_length=100, description="套餐名称") # type: ignore[assignment] + code: str | None = Field(default=None, max_length=100, description="套餐编码") # type: ignore[assignment] + status: int | None = Field(default=None, ge=0, le=1, description="状态(0:正常 1:禁用)") sort: int | None = Field(default=None, ge=0, description="排序") description: str | None = Field(default=None, max_length=255, description="描述") + price: int | None = Field(default=None, ge=0, description="价格(分)") + period: str | None = Field(default=None, pattern=r"^(month|year)$", description="计费周期") + trial_days: int | None = Field(default=None, ge=0, description="免费试用天数") + max_users: int | None = Field(default=None, ge=0, description="最大用户数") + max_roles: int | None = Field(default=None, ge=0, description="最大角色数") + max_depts: int | None = Field(default=None, ge=0, description="最大部门数") + max_storage_mb: int | None = Field(default=None, ge=0, description="最大存储(MB)") + rate_limit: int | None = Field(default=None, ge=10, description="API速率限制(请求/10秒)") @field_validator("code") @classmethod @@ -61,10 +79,10 @@ class PackageUpdateSchema(BaseModel): @field_validator("status") @classmethod - def _validate_status(cls, v: str | None) -> str | None: + def _validate_status(cls, v: int | None) -> int | None: if v is None: return v - if v not in {"0", "1"}: + if v not in {0, 1}: raise ValueError("状态仅支持 0(正常) 或 1(禁用)") return v @@ -75,6 +93,7 @@ class PackageOutSchema(PackageCreateSchema, BaseSchema): model_config = ConfigDict(from_attributes=True) +@dataclass class PackageQueryParam: """套餐查询参数""" @@ -96,3 +115,9 @@ class PackageMenuSetSchema(BaseModel): """批量设置套餐菜单权限""" menu_ids: list[int] = Field(..., description="菜单ID列表") + + +class PackagePluginSetSchema(BaseModel): + """批量设置套餐插件""" + + plugin_ids: list[int] = Field(..., description="插件ID列表") diff --git a/backend/app/api/v1/module_platform/package/service.py b/backend/app/api/v1/module_platform/package/service.py index f8f09650..3bfa6e95 100644 --- a/backend/app/api/v1/module_platform/package/service.py +++ b/backend/app/api/v1/module_platform/package/service.py @@ -2,16 +2,17 @@ import sqlalchemy as sa from sqlalchemy import func, select from app.api.v1.module_platform.tenant.model import TenantModel -from app.api.v1.module_system.auth.schema import AuthSchema +from app.core.base_schema import AuthSchema from app.core.exceptions import CustomException -from app.core.logger import log +from app.core.logger import logger from .crud import PackageCRUD -from .model import PackageMenuModel, PackageModel +from .model import PackageMenuModel, PackageModel, PackagePluginModel from .schema import ( PackageCreateSchema, PackageMenuSetSchema, PackageOutSchema, + PackagePluginSetSchema, PackageQueryParam, PackageUpdateSchema, ) @@ -21,11 +22,11 @@ class PackageService: """套餐模块服务层""" @classmethod - async def detail_service(cls, auth: AuthSchema, id: int) -> dict: - obj = await PackageCRUD(auth).get_by_id_crud(id=id) + async def detail_service(cls, auth: AuthSchema, id: int) -> PackageOutSchema: + obj = await PackageCRUD(auth).get(id=id) if not obj: raise CustomException(msg="套餐不存在") - return PackageOutSchema.model_validate(obj).model_dump() + return PackageOutSchema.model_validate(obj) @classmethod async def page_service( @@ -36,7 +37,7 @@ class PackageService: search: PackageQueryParam | None = None, order_by: list[dict[str, str]] | None = None, ) -> dict: - return await PackageCRUD(auth).page_crud( + return await PackageCRUD(auth).page( offset=(page_no - 1) * page_size, limit=page_size, order_by=order_by or [{"sort": "asc"}, {"id": "asc"}], @@ -45,24 +46,22 @@ class PackageService: ) @classmethod - async def create_service(cls, auth: AuthSchema, data: PackageCreateSchema) -> dict: + async def create_service(cls, auth: AuthSchema, data: PackageCreateSchema) -> PackageOutSchema: if await PackageCRUD(auth).get(name=data.name): raise CustomException(msg="创建失败，套餐名称已存在") if await PackageCRUD(auth).get(code=data.code): raise CustomException(msg="创建失败，套餐编码已存在") - obj = await PackageCRUD(auth).create_crud(data=data) - if not obj: - raise CustomException(msg="创建套餐失败") - result = PackageOutSchema.model_validate(obj).model_dump() - log.info(f"创建套餐成功: {result.get('name')}") + obj = await PackageCRUD(auth).create(data=data) + result = PackageOutSchema.model_validate(obj) + logger.info(f"创建套餐成功: {result.name}") return result @classmethod async def update_service( cls, auth: AuthSchema, id: int, data: PackageUpdateSchema - ) -> dict: - obj = await PackageCRUD(auth).get_by_id_crud(id=id) + ) -> PackageOutSchema: + obj = await PackageCRUD(auth).get(id=id) if not obj: raise CustomException(msg="套餐不存在") @@ -75,10 +74,13 @@ class PackageService: if exist and exist.id != id: raise CustomException(msg="更新失败，编码重复") - updated = await PackageCRUD(auth).update_crud(id=id, data=data) - if not updated: - raise CustomException(msg="更新失败") - return PackageOutSchema.model_validate(updated).model_dump() + # 套餐禁用时记录受影响租户 + if data.status is not None and data.status == 1 and obj.status == 0: + await cls.disable_cascade_service(auth=auth, package_id=id) + + updated = await PackageCRUD(auth).update(id=id, data=data) + + return PackageOutSchema.model_validate(updated) @classmethod async def delete_service(cls, auth: AuthSchema, ids: list[int]) -> None: @@ -92,7 +94,20 @@ class PackageService: if count and count > 0: raise CustomException(msg=f"套餐 ID={pid} 已被 {count} 个租户使用，无法删除") - await PackageCRUD(auth).delete_crud(ids=ids) + await PackageCRUD(auth).delete(ids=ids) + + @classmethod + async def disable_cascade_service(cls, auth: AuthSchema, package_id: int) -> None: + """套餐禁用时日志记录受影响租户""" + stmt = select(TenantModel.id, TenantModel.name).where( + TenantModel.package_id == package_id, + TenantModel.status == 0, + ) + result = await auth.db.execute(stmt) + rows = result.all() + if rows: + tenant_ids = [row[0] for row in rows] + logger.warning(f"套餐[{package_id}]已禁用，影响租户: {tenant_ids}") @classmethod async def get_menus_service(cls, auth: AuthSchema, package_id: int) -> list[int]: @@ -105,12 +120,13 @@ class PackageService: async def set_menus_service( cls, auth: AuthSchema, package_id: int, data: PackageMenuSetSchema ) -> None: + """批量设置套餐菜单权限（先清空再写入）""" await auth.db.execute(sa.delete(PackageMenuModel).where(PackageMenuModel.package_id == package_id)) for menu_id in data.menu_ids: auth.db.add(PackageMenuModel(package_id=package_id, menu_id=menu_id)) await auth.db.flush() - log.info(f"套餐[{package_id}]菜单权限已设置, count={len(data.menu_ids)}") + logger.info(f"套餐[{package_id}]菜单权限已设置, count={len(data.menu_ids)}") @staticmethod async def get_package_menu_ids(auth: AuthSchema, package_id: int) -> list[int]: @@ -121,8 +137,17 @@ class PackageService: @staticmethod async def get_tenant_available_menu_ids(auth: AuthSchema, tenant_id: int) -> list[int]: - """获取租户的完整可用菜单ID列表（套餐菜单 + 自定义授权菜单）""" - from app.api.v1.module_platform.tenant.model import TenantMenuModel, TenantModel + """获取租户的完整可用菜单ID列表（仅从套餐菜单获取） + + 平台租户 (id=1) 返回全部启用菜单，不受套餐限制。 + """ + from app.api.v1.module_platform.menu.model import MenuModel + from app.api.v1.module_platform.tenant.model import TenantModel + + if tenant_id == 1: + menu_stmt = select(MenuModel.id).where(MenuModel.status == 0) + result = await auth.db.execute(menu_stmt) + return [row[0] for row in result.all()] stmt = select(TenantModel).where(TenantModel.id == tenant_id).limit(1) result = await auth.db.execute(stmt) @@ -130,21 +155,60 @@ class PackageService: if not tenant: return [] - all_menu_ids: set[int] = set() + if not tenant.package_id: + return [] - if tenant.package_id: - pkg_stmt = select(PackageModel.status).where(PackageModel.id == tenant.package_id).limit(1) - pkg_result = await auth.db.execute(pkg_stmt) - pkg_status = pkg_result.scalar_one_or_none() - if pkg_status == "0": - stmt = select(PackageMenuModel.menu_id).where(PackageMenuModel.package_id == tenant.package_id) - result = await auth.db.execute(stmt) - for row in result.all(): - all_menu_ids.add(row[0]) + pkg_stmt = select(PackageModel.status).where(PackageModel.id == tenant.package_id).limit(1) + pkg_result = await auth.db.execute(pkg_stmt) + pkg_status = pkg_result.scalar_one_or_none() + if pkg_status != 0: + return [] - stmt = select(TenantMenuModel.menu_id).where(TenantMenuModel.tenant_id == tenant_id) + menu_stmt = select(PackageMenuModel.menu_id).where(PackageMenuModel.package_id == tenant.package_id) + result = await auth.db.execute(menu_stmt) + return [row[0] for row in result.all()] + + @staticmethod + async def get_tenant_available_plugin_ids(auth: AuthSchema, tenant_id: int) -> list[int]: + """获取租户套餐可用的插件ID列表""" + from app.api.v1.module_platform.tenant.model import TenantModel + + stmt = select(TenantModel).where(TenantModel.id == tenant_id).limit(1) result = await auth.db.execute(stmt) - for row in result.all(): - all_menu_ids.add(row[0]) + tenant = result.scalar_one_or_none() + if not tenant or not tenant.package_id: + return [] - return list(all_menu_ids) + pkg_stmt = select(PackageModel.status).where(PackageModel.id == tenant.package_id).limit(1) + pkg_result = await auth.db.execute(pkg_stmt) + pkg_status = pkg_result.scalar_one_or_none() + if pkg_status != 0: + return [] + + plugin_stmt = select(PackagePluginModel.plugin_id).where( + PackagePluginModel.package_id == tenant.package_id + ) + result = await auth.db.execute(plugin_stmt) + return [row[0] for row in result.all()] + + @classmethod + async def get_plugins_service(cls, auth: AuthSchema, package_id: int) -> list[int]: + """获取套餐插件权限（返回 plugin_id 列表）""" + stmt = select(PackagePluginModel.plugin_id).where( + PackagePluginModel.package_id == package_id + ) + result = await auth.db.execute(stmt) + return [row[0] for row in result.all()] + + @classmethod + async def set_plugins_service( + cls, auth: AuthSchema, package_id: int, data: PackagePluginSetSchema + ) -> None: + """批量设置套餐插件（先清空再写入）""" + await auth.db.execute( + sa.delete(PackagePluginModel).where(PackagePluginModel.package_id == package_id) + ) + for plugin_id in data.plugin_ids: + auth.db.add(PackagePluginModel(package_id=package_id, plugin_id=plugin_id)) + await auth.db.flush() + logger.info(f"套餐[{package_id}]插件已设置, count={len(data.plugin_ids)}") diff --git a/backend/app/api/v1/module_platform/plugin/__init__.py b/backend/app/api/v1/module_platform/plugin/__init__.py index e69de29b..55b9cd2c 100644 --- a/backend/app/api/v1/module_platform/plugin/__init__.py +++ b/backend/app/api/v1/module_platform/plugin/__init__.py @@ -0,0 +1,3 @@ +from .controller import PluginRouter + +__all__ = ["PluginRouter"] diff --git a/backend/app/api/v1/module_platform/plugin/controller.py b/backend/app/api/v1/module_platform/plugin/controller.py index 5befb03e..5725f945 100644 --- a/backend/app/api/v1/module_platform/plugin/controller.py +++ b/backend/app/api/v1/module_platform/plugin/controller.py @@ -1,10 +1,13 @@ from typing import Annotated from fastapi import APIRouter, Body, Depends, Path +from fastapi.responses import JSONResponse +from fastapi_cache import FastAPICache +from fastapi_cache.decorator import cache -from app.api.v1.module_system.auth.schema import AuthSchema from app.common.response import ResponseSchema, SuccessResponse from app.core.base_params import PaginationQueryParam +from app.core.base_schema import AuthSchema, PageResultSchema from app.core.dependencies import AuthPermission from app.core.router_class import OperationLogRoute @@ -17,18 +20,30 @@ from .schema import ( ) from .service import PluginService -PluginRouter = APIRouter(route_class=OperationLogRoute, prefix="/plugin", tags=["插件管理"]) +PluginRouter = APIRouter(route_class=OperationLogRoute, prefix="/plugin", tags=["平台管理/插件管理"]) +_PLUGIN_NS = "plugin" # ───── 超管：插件 CRUD ───── -@PluginRouter.get("/list", summary="插件列表", response_model=ResponseSchema[dict]) +@PluginRouter.get("/list", summary="插件列表", response_model=ResponseSchema[PageResultSchema[PluginOutSchema]]) +@cache(expire=300, namespace=_PLUGIN_NS) async def plugin_list( page: Annotated[PaginationQueryParam, Depends()], search: Annotated[PluginQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:plugin:query"]))], -): + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:plugin:query']))], +) -> JSONResponse: + """ + 插件列表 + + 参数: + - page (PaginationQueryParam): 分页查询参数。 + - search (PluginQueryParam): 查询筛选参数。 + + 返回: + - JSONResponse: 包含分页插件列表的 JSON 响应。 + """ r = await PluginService.page_service(auth, page.page_no, page.page_size, search, page.order_by) return SuccessResponse(data=r, msg="查询成功") @@ -38,17 +53,37 @@ async def plugin_list( ) async def plugin_detail( id: Annotated[int, Path()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:plugin:query"]))], -): + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:plugin:query']))], +) -> JSONResponse: + """ + 插件详情 + + 参数: + - id (int): 插件 ID。 + + 返回: + - JSONResponse: 包含插件详情的 JSON 响应。 + """ return SuccessResponse(data=await PluginService.detail_service(auth, id), msg="查询成功") @PluginRouter.post("/create", summary="创建插件", response_model=ResponseSchema[PluginOutSchema]) async def plugin_create( data: PluginCreateSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:plugin:create"]))], -): - return SuccessResponse(data=await PluginService.create_service(auth, data), msg="创建成功") + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:plugin:create']))], +) -> JSONResponse: + """ + 创建插件 + + 参数: + - data (PluginCreateSchema): 插件创建参数。 + + 返回: + - JSONResponse: 包含创建后的插件详情的 JSON 响应。 + """ + r = await PluginService.create_service(auth, data) + await FastAPICache.clear(namespace=_PLUGIN_NS) + return SuccessResponse(data=r, msg="创建成功") @PluginRouter.put( @@ -57,62 +92,146 @@ async def plugin_create( async def plugin_update( id: Annotated[int, Path()], data: PluginUpdateSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:plugin:update"]))], -): - return SuccessResponse(data=await PluginService.update_service(auth, id, data), msg="更新成功") + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:plugin:update']))], +) -> JSONResponse: + """ + 更新插件 + + 参数: + - id (int): 插件 ID。 + - data (PluginUpdateSchema): 插件更新参数。 + + 返回: + - JSONResponse: 包含更新后的插件详情的 JSON 响应。 + """ + r = await PluginService.update_service(auth, id, data) + await FastAPICache.clear(namespace=_PLUGIN_NS) + return SuccessResponse(data=r, msg="更新成功") -@PluginRouter.delete("/delete", summary="删除插件") +@PluginRouter.delete("/delete", summary="删除插件", response_model=ResponseSchema[None]) async def plugin_delete( ids: Annotated[list[int], Body()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:plugin:delete"]))], -): - await PluginService.delete_service(auth, ids) - return SuccessResponse(msg="删除成功") + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:plugin:delete']))], +) -> JSONResponse: + """ + 删除插件 + 参数: + - ids (list[int]): 插件 ID 列表。 + + 返回: + - JSONResponse: 删除结果。 + """ + await PluginService.delete_service(auth, ids) + await FastAPICache.clear(namespace=_PLUGIN_NS) + return SuccessResponse(msg="删除成功") # ───── 租户：插件市场 ───── -@PluginRouter.get("/marketplace", summary="插件市场", response_model=ResponseSchema[dict]) +@PluginRouter.get("/marketplace", summary="插件市场", response_model=ResponseSchema[PageResultSchema[PluginOutSchema]]) +@cache(expire=600, namespace=_PLUGIN_NS) async def marketplace( page: Annotated[PaginationQueryParam, Depends()], category: str | None = None, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:plugin:query"]))] = None, -): + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:plugin:query']))] = None, +) -> JSONResponse: + """ + 插件市场 + + 参数: + - page (PaginationQueryParam): 分页查询参数。 + - category (str | None): 分类筛选。 + + 返回: + - JSONResponse: 包含分页市场插件列表的 JSON 响应。 + """ r = await PluginService.marketplace_service(auth, page.page_no, page.page_size, category) return SuccessResponse(data=r, msg="查询成功") -@PluginRouter.post("/install", summary="安装插件") +@PluginRouter.post("/install", summary="安装插件", response_model=ResponseSchema[None]) async def plugin_install( data: PluginInstallSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:plugin:install"]))], -): + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:plugin:install']))], +) -> JSONResponse: + """ + 安装插件 + + 参数: + - data (PluginInstallSchema): 安装参数（插件 ID）。 + + 返回: + - JSONResponse: 安装结果。 + """ await PluginService.install_service(auth, data.plugin_id) + await FastAPICache.clear(namespace=_PLUGIN_NS) return SuccessResponse(msg="安装成功") -@PluginRouter.post("/uninstall", summary="卸载插件") +@PluginRouter.post("/uninstall", summary="卸载插件", response_model=ResponseSchema[None]) async def plugin_uninstall( data: PluginInstallSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:plugin:uninstall"]))], -): + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:plugin:uninstall']))], +) -> JSONResponse: + """ + 卸载插件 + + 参数: + - data (PluginInstallSchema): 卸载参数（插件 ID）。 + + 返回: + - JSONResponse: 卸载结果。 + """ await PluginService.uninstall_service(auth, data.plugin_id) + await FastAPICache.clear(namespace=_PLUGIN_NS) return SuccessResponse(msg="卸载成功") -@PluginRouter.post("/toggle", summary="启用/禁用插件") +@PluginRouter.post("/toggle", summary="启用/禁用插件", response_model=ResponseSchema[None]) async def plugin_toggle( data: PluginInstallSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:plugin:toggle"]))], -): + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:plugin:toggle']))], +) -> JSONResponse: + """ + 启用/禁用插件 + + 参数: + - data (PluginInstallSchema): 操作参数（插件 ID）。 + + 返回: + - JSONResponse: 操作结果。 + """ await PluginService.toggle_service(auth, data.plugin_id) + await FastAPICache.clear(namespace=_PLUGIN_NS) return SuccessResponse(msg="操作成功") @PluginRouter.get("/my", summary="我的插件", response_model=ResponseSchema[list[PluginOutSchema]]) +@cache(expire=120, namespace=_PLUGIN_NS) async def my_plugins( - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:plugin:query"]))], -): + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:plugin:query']))], +) -> JSONResponse: + """ + 我的插件 + + 返回: + - JSONResponse: 包含已安装插件列表的 JSON 响应。 + """ return SuccessResponse(data=await PluginService.my_plugins_service(auth), msg="查询成功") + + +@PluginRouter.post("/reload", summary="热重载插件路由", response_model=ResponseSchema[str]) +async def plugin_reload( + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_platform:plugin:reload']))], +) -> JSONResponse: + """ + 热重载插件路由（管理员）。 + + 重新扫描 app/plugin/module_* 目录，清除模块缓存并注册新路由， + 无需重启服务器。 + """ + msg = PluginService.reload_service() + await FastAPICache.clear(namespace=_PLUGIN_NS) + return SuccessResponse(data=msg, msg="重载成功") diff --git a/backend/app/api/v1/module_platform/plugin/crud.py b/backend/app/api/v1/module_platform/plugin/crud.py index d5e85288..4735d0ad 100644 --- a/backend/app/api/v1/module_platform/plugin/crud.py +++ b/backend/app/api/v1/module_platform/plugin/crud.py @@ -1,11 +1,12 @@ -from app.api.v1.module_system.auth.schema import AuthSchema from app.core.base_crud import CRUDBase +from app.core.base_schema import AuthSchema from .model import PluginModel from .schema import PluginCreateSchema, PluginUpdateSchema class PluginCRUD(CRUDBase[PluginModel, PluginCreateSchema, PluginUpdateSchema]): + """插件数据层""" + def __init__(self, auth: AuthSchema) -> None: - self.auth = auth super().__init__(model=PluginModel, auth=auth) diff --git a/backend/app/api/v1/module_platform/plugin/model.py b/backend/app/api/v1/module_platform/plugin/model.py index 75851254..762f060e 100644 --- a/backend/app/api/v1/module_platform/plugin/model.py +++ b/backend/app/api/v1/module_platform/plugin/model.py @@ -14,7 +14,6 @@ class PluginModel(ModelMixin): code: Mapped[str] = mapped_column( String(50), nullable=False, unique=True, comment="插件编码(module_xxx)" ) - description: Mapped[str | None] = mapped_column(Text, nullable=True, comment="插件描述") version: Mapped[str] = mapped_column( String(20), nullable=False, default="1.0.0", comment="版本号" ) @@ -77,4 +76,7 @@ class TenantPluginModel(MappedBase): enabled: Mapped[str] = mapped_column( String(1), nullable=False, default="1", comment="启用(1:启用 0:禁用)" ) + purchased: Mapped[str] = mapped_column( + String(1), nullable=False, default="0", comment="是否已购买(1:已购买 0:未购买)" + ) installed_time: Mapped[DateTime] = mapped_column(DateTime, nullable=False, comment="安装时间") diff --git a/backend/app/api/v1/module_platform/plugin/schema.py b/backend/app/api/v1/module_platform/plugin/schema.py index ab27101a..f61502b3 100644 --- a/backend/app/api/v1/module_platform/plugin/schema.py +++ b/backend/app/api/v1/module_platform/plugin/schema.py @@ -1,7 +1,14 @@ +from dataclasses import dataclass + from pydantic import BaseModel, ConfigDict, Field, field_validator +from app.common.enums import QueueEnum +from app.core.base_schema import BaseSchema + class PluginCreateSchema(BaseModel): + """新增插件""" + name: str = Field(..., min_length=1, max_length=100, description="插件名称") code: str = Field(..., min_length=1, max_length=50, description="插件编码（如 module_xxx）") description: str | None = Field(default=None, max_length=255, description="插件描述") @@ -42,70 +49,50 @@ class PluginCreateSchema(BaseModel): return v -class PluginUpdateSchema(BaseModel): - name: str | None = Field(default=None, max_length=100, description="插件名称") - description: str | None = Field(default=None, max_length=255, description="插件描述") - version: str | None = Field(default=None, max_length=20, description="版本号") - author: str | None = Field(default=None, max_length=100, description="作者") - icon: str | None = Field(default=None, max_length=500, description="图标URL") - category: str | None = Field(default=None, max_length=20, description="分类") - price: int | None = Field(default=None, ge=0, description="价格(分，0=免费)") - menu_path: str | None = Field(default=None, max_length=200, description="菜单路径") - permission_prefix: str | None = Field(default=None, max_length=100, description="权限前缀") - dependencies: str | None = Field(default=None, description="依赖插件编码(JSON数组)") - sort: int | None = Field(default=None, ge=0, description="排序") - status: str | None = Field(default=None, max_length=1, description="状态(0:正常 1:禁用)") +class PluginUpdateSchema(PluginCreateSchema): + """更新插件 — 所有字段可选""" - @field_validator("category") - @classmethod - def _validate_category(cls, v: str | None) -> str | None: - if v is None: - return v - allowed = {"tool", "ai", "monitor", "business"} - if v not in allowed: - raise ValueError(f"插件分类仅支持 tool、ai、monitor、business，当前值: {v}") - return v + name: str | None = Field(default=None, max_length=100, description="插件名称") # type: ignore[assignment] + code: str | None = Field(default=None, max_length=50, description="插件编码") # type: ignore[assignment] + status: int | None = Field(default=None, ge=0, le=1, description="状态(0:正常 1:禁用)") @field_validator("status") @classmethod - def _validate_status(cls, v: str | None) -> str | None: + def _validate_status(cls, v: int | None) -> int | None: if v is None: return v - if v not in {"0", "1"}: + if v not in {0, 1}: raise ValueError("状态仅支持 0(正常) 或 1(禁用)") return v -class PluginOutSchema(BaseModel): +class PluginOutSchema(PluginCreateSchema, BaseSchema): + """插件响应""" + model_config = ConfigDict(from_attributes=True) - id: int - name: str - code: str - description: str | None = None - version: str - author: str | None = None - icon: str | None = None - category: str - price: int - menu_path: str | None = None - permission_prefix: str | None = None - dependencies: str | None = None - sort: int - status: str + installed: bool = False # 当前租户是否已安装 -class PluginQueryParam: - def __init__( - self, name: str | None = None, category: str | None = None, status: str | None = None - ): - if name: - self.name = ("like", name) - if category: - self.category = ("eq", category) - if status: - self.status = ("eq", status) - - class PluginInstallSchema(BaseModel): + """安装/卸载插件""" + plugin_id: int = Field(..., description="插件ID") + + +@dataclass +class PluginQueryParam: + """插件查询参数""" + + def __init__( + self, + name: str | None = None, + category: str | None = None, + status: str | None = None, + ) -> None: + if name: + self.name = (QueueEnum.like.value, name) + if category: + self.category = (QueueEnum.eq.value, category) + if status: + self.status = (QueueEnum.eq.value, status) diff --git a/backend/app/api/v1/module_platform/plugin/service.py b/backend/app/api/v1/module_platform/plugin/service.py index 60fd207d..86bf11d5 100644 --- a/backend/app/api/v1/module_platform/plugin/service.py +++ b/backend/app/api/v1/module_platform/plugin/service.py @@ -2,9 +2,9 @@ from datetime import datetime import sqlalchemy as sa -from app.api.v1.module_system.auth.schema import AuthSchema +from app.core.base_schema import AuthSchema from app.core.exceptions import CustomException -from app.core.logger import log +from app.core.logger import logger from .crud import PluginCRUD from .model import PluginModel, TenantPluginModel @@ -12,8 +12,6 @@ from .schema import PluginCreateSchema, PluginOutSchema, PluginQueryParam, Plugi class PluginService: - def __init__(self): - raise RuntimeError("Service is stateless, use classmethods") @classmethod async def page_service( @@ -33,26 +31,26 @@ class PluginService: ) @classmethod - async def detail_service(cls, auth: AuthSchema, id: int) -> dict: + async def detail_service(cls, auth: AuthSchema, id: int) -> PluginOutSchema: obj = await PluginCRUD(auth).get(id=id) if not obj: raise CustomException(msg="插件不存在") - return PluginOutSchema.model_validate(obj).model_dump() + return PluginOutSchema.model_validate(obj) @classmethod - async def create_service(cls, auth: AuthSchema, data: PluginCreateSchema) -> dict: + async def create_service(cls, auth: AuthSchema, data: PluginCreateSchema) -> PluginOutSchema: if await PluginCRUD(auth).get(code=data.code): raise CustomException(msg="插件编码已存在") obj = await PluginCRUD(auth).create(data=data) - return PluginOutSchema.model_validate(obj).model_dump() + return PluginOutSchema.model_validate(obj) @classmethod - async def update_service(cls, auth: AuthSchema, id: int, data: PluginUpdateSchema) -> dict: + async def update_service(cls, auth: AuthSchema, id: int, data: PluginUpdateSchema) -> PluginOutSchema: obj = await PluginCRUD(auth).get(id=id) if not obj: raise CustomException(msg="插件不存在") updated = await PluginCRUD(auth).update(id=id, data=data) - return PluginOutSchema.model_validate(updated).model_dump() + return PluginOutSchema.model_validate(updated) @classmethod async def delete_service(cls, auth: AuthSchema, ids: list[int]) -> None: @@ -76,16 +74,17 @@ class PluginService: out_schema=PluginOutSchema, ) tenant_id = getattr(auth, "tenant_id", None) or auth.user.tenant_id - if tenant_id and result.get("items"): - installed = await auth.db.execute( - sa.select(TenantPluginModel.plugin_id).where( + if tenant_id and result.items: + records = await auth.db.execute( + sa.select(TenantPluginModel.plugin_id, TenantPluginModel.purchased).where( TenantPluginModel.tenant_id == tenant_id, - TenantPluginModel.enabled == "0", ) ) - installed_ids = {r[0] for r in installed.all()} - for item in result["items"]: - item["installed"] = item["id"] in installed_ids + record_map = {r[0]: r[1] for r in records.all()} + for item in result.items: + pid = item["id"] + item["installed"] = pid in record_map + item["purchased"] = record_map.get(pid, "0") == "1" return result @classmethod @@ -93,9 +92,36 @@ class PluginService: tenant_id = getattr(auth, "tenant_id", None) or auth.user.tenant_id if not tenant_id: raise CustomException(msg="无法获取租户信息") + + # 平台租户不限制插件安装 + if tenant_id != 1: + from app.api.v1.module_platform.package.service import PackageService + allowed_plugin_ids = await PackageService.get_tenant_available_plugin_ids( + auth, tenant_id + ) + # 套餐有插件配置时，仅允许安装套餐内的插件 + if allowed_plugin_ids and plugin_id not in allowed_plugin_ids: + raise CustomException(msg="当前套餐不支持安装此插件") + plugin = await PluginCRUD(auth).get(id=plugin_id) - if not plugin or plugin.status == "1": + if not plugin or plugin.status == 1: raise CustomException(msg="插件不可用") + + # 付费插件需要先购买 + if tenant_id != 1 and getattr(plugin, "price", 0) > 0: + exist = await auth.db.execute( + sa + .select(TenantPluginModel) + .where( + TenantPluginModel.tenant_id == tenant_id, + TenantPluginModel.plugin_id == plugin_id, + ) + .limit(1) + ) + tp_record = exist.scalar_one_or_none() + if not tp_record or tp_record.purchased != "1": + raise CustomException(msg="此插件为付费插件，请先购买后再安装") + exist = await auth.db.execute( sa .select(TenantPluginModel) @@ -117,11 +143,15 @@ class PluginService: ) else: tp = TenantPluginModel( - tenant_id=tenant_id, plugin_id=plugin_id, enabled="0", installed_time=datetime.now() + tenant_id=tenant_id, + plugin_id=plugin_id, + enabled="0", + purchased="1" if getattr(plugin, "price", 0) == 0 else "0", + installed_time=datetime.now(), ) auth.db.add(tp) await auth.db.flush() - log.info(f"租户[{tenant_id}]安装插件[{plugin.name}]") + logger.info(f"租户[{tenant_id}]安装插件[{plugin.name}]") @classmethod async def uninstall_service(cls, auth: AuthSchema, plugin_id: int) -> None: @@ -135,7 +165,7 @@ class PluginService: ) ) await auth.db.flush() - log.info(f"租户[{tenant_id}]卸载插件[{plugin_id}]") + logger.info(f"租户[{tenant_id}]卸载插件[{plugin_id}]") @classmethod async def toggle_service(cls, auth: AuthSchema, plugin_id: int) -> None: @@ -154,7 +184,7 @@ class PluginService: raise CustomException(msg="未安装该插件") tp.enabled = "1" if tp.enabled == "0" else "0" await auth.db.flush() - log.info(f"租户[{tenant_id}]插件[{plugin_id}]状态→{tp.enabled}") + logger.info(f"租户[{tenant_id}]插件[{plugin_id}]状态→{tp.enabled}") @classmethod async def my_plugins_service(cls, auth: AuthSchema) -> list[dict]: @@ -170,7 +200,7 @@ class PluginService: ) plugins = [] for p, tp in result.all(): - d = PluginOutSchema.model_validate(p).model_dump() + d = PluginOutSchema.model_validate(p) d["enabled"] = tp.enabled d["installed"] = True d["installed_time"] = ( @@ -178,3 +208,23 @@ class PluginService: ) plugins.append(d) return plugins + + # ───── 插件热重载 ───── + + @classmethod + def reload_service(cls) -> str: + """ + 热重载插件路由（同步函数，直接操作模块缓存与 app.routes）。 + + 要求 init_app.py 已在启动时调用 discover.set_app_ref(app)， + 否则仅重建 Router 对象，不会更新运行中的 app 路由。 + + 返回: + - str: 重载结果描述 + """ + from app.core.discover import reload_dynamic_router + + router = reload_dynamic_router() + route_count = len(router.routes) if router and hasattr(router, "routes") else 0 + logger.info(f"插件热重载完成，动态路由共 {route_count} 条") + return f"插件路由热重载完成，共注册 {route_count} 条路由" diff --git a/backend/app/api/v1/module_platform/self_service/__init__.py b/backend/app/api/v1/module_platform/self_service/__init__.py new file mode 100644 index 00000000..17dbe299 --- /dev/null +++ b/backend/app/api/v1/module_platform/self_service/__init__.py @@ -0,0 +1,3 @@ +from .controller import TenantSelfServiceRouter + +__all__ = ["TenantSelfServiceRouter"] diff --git a/backend/app/api/v1/module_platform/self_service/controller.py b/backend/app/api/v1/module_platform/self_service/controller.py new file mode 100644 index 00000000..e1d7f808 --- /dev/null +++ b/backend/app/api/v1/module_platform/self_service/controller.py @@ -0,0 +1,197 @@ +"""租户自助服务 Controller — 对应 PRD §20.20""" +from typing import Annotated + +from fastapi import APIRouter, Depends, Path, Query + +from app.common.response import ResponseSchema, SuccessResponse +from app.core.base_params import PaginationQueryParam +from app.core.base_schema import AuthSchema +from app.core.dependencies import AuthPermission, get_current_user +from app.core.router_class import OperationLogRoute + +from .schema import ( + PackageAvailableOut, + PackagePreviewOut, + PluginPurchaseCreate, + SelfOrderCreate, + SelfOrderDetailOut, + SelfOrderListOut, + SelfOrderOut, + WorkspaceOut, +) +from .service import ( + create_plugin_purchase_order, + create_self_order, + get_available_packages, + get_self_order_detail, + get_self_order_list, + preview_package_change, +) + +TenantSelfServiceRouter = APIRouter( + route_class=OperationLogRoute, + prefix="/tenant", + tags=["平台管理/自助服务"], +) + + +@TenantSelfServiceRouter.get( + "/package/available", + summary="可选套餐列表", + response_model=ResponseSchema[PackageAvailableOut], +) +async def package_available( + auth: Annotated[AuthSchema, Depends(AuthPermission(['tenant:package:query']))], +): + """ + 可选套餐列表 + + 返回: + - SuccessResponse: 包含可用套餐列表的 JSON 响应。 + """ + result = await get_available_packages(auth=auth, tenant_id=auth.tenant_id) + return SuccessResponse(data=result, msg="查询成功") + + +@TenantSelfServiceRouter.get( + "/package/preview", + summary="套餐变更影响预览", + response_model=ResponseSchema[PackagePreviewOut], +) +async def package_preview( + target_package_id: Annotated[int, Query(ge=1, description="目标套餐ID")], + auth: Annotated[AuthSchema, Depends(AuthPermission(['tenant:package:query']))], +): + """ + 套餐变更影响预览 + + 参数: + - target_package_id (int): 目标套餐 ID。 + + 返回: + - SuccessResponse: 包含套餐变更影响预览的 JSON 响应。 + """ + result = await preview_package_change( + auth=auth, tenant_id=auth.tenant_id, target_package_id=target_package_id + ) + return SuccessResponse(data=result, msg="查询成功") + + +@TenantSelfServiceRouter.post( + "/order/create", + summary="创建自助订单", + response_model=ResponseSchema[SelfOrderOut], +) +async def order_create( + data: SelfOrderCreate, + auth: Annotated[AuthSchema, Depends(AuthPermission(['tenant:order:create']))], +): + """ + 创建自助订单 + + 参数: + - data (SelfOrderCreate): 订单创建参数。 + + 返回: + - SuccessResponse: 包含订单详情的 JSON 响应。 + """ + result = await create_self_order( + auth=auth, tenant_id=auth.tenant_id, data=data + ) + return SuccessResponse(data=result, msg="订单创建成功") + + +@TenantSelfServiceRouter.post( + "/plugin/purchase", + summary="购买付费插件", + response_model=ResponseSchema[SelfOrderOut], +) +async def plugin_purchase( + data: PluginPurchaseCreate, + auth: Annotated[AuthSchema, Depends(AuthPermission(['tenant:order:create']))], +): + """ + 购买付费插件 + + 参数: + - data (PluginPurchaseCreate): 插件购买参数。 + + 返回: + - SuccessResponse: 包含订单详情的 JSON 响应。 + """ + result = await create_plugin_purchase_order( + auth=auth, tenant_id=auth.tenant_id, data=data + ) + return SuccessResponse(data=result, msg="插件订单创建成功") + + +@TenantSelfServiceRouter.get( + "/order/list", + summary="我的订单列表", + response_model=ResponseSchema[SelfOrderListOut], +) +async def order_list( + page: Annotated[PaginationQueryParam, Depends()], + auth: Annotated[AuthSchema, Depends(AuthPermission(['tenant:order:query']))], +): + """ + 我的订单列表 + + 参数: + - page (PaginationQueryParam): 分页查询参数。 + + 返回: + - SuccessResponse: 包含分页订单列表的 JSON 响应。 + """ + result = await get_self_order_list( + auth=auth, + tenant_id=auth.tenant_id, + page_no=page.page_no, + page_size=page.page_size, + order_by=page.order_by, + ) + return SuccessResponse(data=result, msg="查询成功") + + +@TenantSelfServiceRouter.get( + "/order/detail/{order_id}", + summary="订单详情", + response_model=ResponseSchema[SelfOrderDetailOut], +) +async def order_detail( + order_id: Annotated[int, Path(ge=1, description="订单ID")], + auth: Annotated[AuthSchema, Depends(AuthPermission(['tenant:order:query']))], +): + """ + 订单详情 + + 参数: + - order_id (int): 订单 ID。 + + 返回: + - SuccessResponse: 包含订单详情的 JSON 响应。 + """ + result = await get_self_order_detail( + auth=auth, tenant_id=auth.tenant_id, order_id=order_id + ) + return SuccessResponse(data=result, msg="查询成功") + + +@TenantSelfServiceRouter.get( + "/workspace", + summary="租户工作台概览", + response_model=ResponseSchema[WorkspaceOut], +) +async def tenant_workspace( + auth: Annotated[AuthSchema, Depends(get_current_user)], +): + """ + 租户工作台概览 + + 返回: + - SuccessResponse: 包含工作台概览信息的 JSON 响应。 + """ + from .service import get_workspace_data + + result = await get_workspace_data(auth=auth, tenant_id=auth.tenant_id) + return SuccessResponse(data=result, msg="查询成功") diff --git a/backend/app/api/v1/module_platform/self_service/schema.py b/backend/app/api/v1/module_platform/self_service/schema.py new file mode 100644 index 00000000..a081a0d9 --- /dev/null +++ b/backend/app/api/v1/module_platform/self_service/schema.py @@ -0,0 +1,162 @@ +"""租户自助服务 Schema""" +from pydantic import BaseModel, Field + + +class PackageAvailableItem(BaseModel): + """可选套餐项""" + id: int + name: str + price: int # 分 + period: str # month/year + trial_days: int = 0 + max_users: int = 0 + max_roles: int = 0 + max_depts: int = 0 + max_storage_mb: int = 0 + description: str | None = None + is_current: bool = False + available_actions: list[str] = [] # [buy, renew, upgrade, downgrade] + + +class PackageAvailableOut(BaseModel): + """可选套餐列表""" + current_package_id: int | None = None + packages: list[PackageAvailableItem] + + +class PackagePreviewQuery(BaseModel): + """套餐变更预览请求""" + target_package_id: int = Field(..., ge=1) + + +class PackagePreviewOut(BaseModel): + """套餐变更预览结果""" + current_package: str = "" + target_package: str = "" + action: str = "" # upgrade/downgrade/buy/renew + amount: int = 0 # 分 + period: str = "" + gained_menus: list[dict] = [] + lost_menus: list[dict] = [] + affected_roles: list[str] = [] + affected_users: int = 0 + + +class SelfOrderCreate(BaseModel): + """自助订单创建""" + package_id: int = Field(..., ge=1) + order_type: str = Field(..., pattern="^(buy|renew|upgrade|downgrade)$") + + +class PluginPurchaseCreate(BaseModel): + """插件购买""" + plugin_id: int = Field(..., ge=1, description="插件ID") + pay_method: str | None = Field(default=None, pattern=r"^(alipay|wxpay)?$") + + +# ─── 订单 ─── + + +class SelfOrderOut(BaseModel): + """自助订单创建结果""" + order_id: int + order_no: str + amount: int + need_pay: bool + + +class SelfOrderListItem(BaseModel): + """我的订单列表项""" + id: int + order_no: str + package_name: str = "" + order_type: str + amount: int + status: int + pay_method: str | None = None + pay_time: str | None = None + created_at: str | None = None + + +class SelfOrderListOut(BaseModel): + """我的订单列表""" + items: list[SelfOrderListItem] + total: int + page_no: int + page_size: int + + +class SelfOrderDetailOut(BaseModel): + """订单详情""" + id: int + order_no: str + package_id: int | None = None + package_name: str = "" + amount: int + order_type: str + status: int + pay_method: str | None = None + pay_time: str | None = None + created_at: str | None = None + + +# ─── 工作台 ─── + + +class WorkspaceTenantInfo(BaseModel): + """工作台-租户信息""" + id: int + name: str + code: str + status: int + status_label: str + start_time: str | None = None + end_time: str | None = None + days_remaining: int = 0 + + +class WorkspacePackageInfo(BaseModel): + """工作台-套餐信息""" + id: int + name: str + price: int + period: str + max_users: int + max_roles: int + max_depts: int + + +class WorkspaceUsagePercent(BaseModel): + """工作台-用量百分比""" + users: float = 0 + roles: float = 0 + depts: float = 0 + + +class WorkspaceQuotaInfo(BaseModel): + """工作台-配额用量""" + max_users: int = 0 + max_roles: int = 0 + max_depts: int = 0 + current_users: int = 0 + current_roles: int = 0 + current_depts: int = 0 + usage_percent: WorkspaceUsagePercent = Field(default_factory=WorkspaceUsagePercent) + + +class WorkspaceOrderItem(BaseModel): + """工作台-近期订单项""" + id: int + order_no: str + amount: int + order_type: str + status: int + created_at: str | None = None + + +class WorkspaceOut(BaseModel): + """工作台概览""" + tenant: WorkspaceTenantInfo + package: WorkspacePackageInfo | None = None + quota: WorkspaceQuotaInfo + recent_orders: list[WorkspaceOrderItem] = [] diff --git a/backend/app/api/v1/module_platform/self_service/service.py b/backend/app/api/v1/module_platform/self_service/service.py new file mode 100644 index 00000000..ce03863a --- /dev/null +++ b/backend/app/api/v1/module_platform/self_service/service.py @@ -0,0 +1,463 @@ +"""租户自助服务 Service""" +from datetime import datetime, timedelta + +from sqlalchemy import func, select + +from app.api.v1.module_platform.menu.model import MenuModel +from app.api.v1.module_platform.package.model import PackageMenuModel, PackageModel +from app.api.v1.module_platform.tenant.model import TenantModel +from app.api.v1.module_system.role.model import RoleModel +from app.core.base_schema import AuthSchema +from app.core.exceptions import CustomException +from app.core.logger import logger + +from .schema import ( + PackageAvailableItem, + PackageAvailableOut, + PackagePreviewOut, + PluginPurchaseCreate, + SelfOrderCreate, + SelfOrderDetailOut, + SelfOrderListItem, + SelfOrderListOut, + SelfOrderOut, + WorkspaceOrderItem, + WorkspaceOut, + WorkspacePackageInfo, + WorkspaceQuotaInfo, + WorkspaceTenantInfo, + WorkspaceUsagePercent, +) + + +async def get_available_packages(auth: AuthSchema, tenant_id: int) -> PackageAvailableOut: + """获取可选套餐列表""" + tenant = await auth.db.get(TenantModel, tenant_id) + current_pkg_id = tenant.package_id if tenant else None + + # 一次性获取当前套餐价格（可能未启用，不在后续结果中） + current_price: int | None = None + if current_pkg_id: + cp = await auth.db.get(PackageModel, current_pkg_id) + current_price = cp.price if cp else 0 + + stmt = select(PackageModel).where(PackageModel.status == 0).order_by(PackageModel.price) + result = await auth.db.execute(stmt) + packages = result.scalars().all() + + items: list[PackageAvailableItem] = [] + for pkg in packages: + is_current = pkg.id == current_pkg_id + actions: list[str] = [] + if is_current: + actions = ["renew"] + elif current_pkg_id is None: + actions = ["buy"] + elif current_price is not None: + actions = ["upgrade"] if pkg.price > current_price else ["downgrade"] + + items.append(PackageAvailableItem( + id=pkg.id, + name=pkg.name, + price=pkg.price, + period=pkg.period, + trial_days=pkg.trial_days, + max_users=pkg.max_users, + max_roles=pkg.max_roles, + max_depts=pkg.max_depts, + max_storage_mb=pkg.max_storage_mb, + description=pkg.description, + is_current=is_current, + available_actions=actions, + )) + + return PackageAvailableOut( + current_package_id=current_pkg_id, + packages=items, + ) + + +async def preview_package_change( + auth: AuthSchema, tenant_id: int, target_package_id: int +) -> PackagePreviewOut: + """套餐变更影响预览""" + tenant = await auth.db.get(TenantModel, tenant_id) + current_pkg_id = tenant.package_id if tenant else None + + target_pkg = await auth.db.get(PackageModel, target_package_id) + if not target_pkg: + raise CustomException(msg="目标套餐不存在") + + current_pkg = None + if current_pkg_id: + current_pkg = await auth.db.get(PackageModel, current_pkg_id) + + # 获取当前套餐的菜单 + current_menus = set() + if current_pkg_id: + cm_stmt = select(MenuModel).join( + PackageMenuModel, MenuModel.id == PackageMenuModel.menu_id + ).where(PackageMenuModel.package_id == current_pkg_id) + result = await auth.db.execute(cm_stmt) + current_menus = {m.id for m in result.scalars().all()} + + # 获取目标套餐的菜单 + tm_stmt = select(MenuModel).join( + PackageMenuModel, MenuModel.id == PackageMenuModel.menu_id + ).where(PackageMenuModel.package_id == target_package_id) + result = await auth.db.execute(tm_stmt) + target_menus = {m.id for m in result.scalars().all()} + + # 计算差异 + gained_menus, lost_menus = [], [] + if current_menus: + lost_ids = current_menus - target_menus + if lost_ids: + lost_stmt = select(MenuModel).where(MenuModel.id.in_(lost_ids)) + lost = await auth.db.execute(lost_stmt) + lost_menus = [{"id": m.id, "name": m.name, "path": m.route_path} for m in lost.scalars().all()] + + gained_ids = target_menus - (current_menus or set()) + if gained_ids: + gain_stmt = select(MenuModel).where(MenuModel.id.in_(gained_ids)) + gained = await auth.db.execute(gain_stmt) + gained_menus = [{"id": m.id, "name": m.name, "path": m.route_path} for m in gained.scalars().all()] + + # 确定操作类型 + if current_pkg_id is None: + action = "buy" + elif current_pkg and target_pkg.price > current_pkg.price: + action = "upgrade" + elif current_pkg and target_pkg.price < current_pkg.price: + action = "downgrade" + else: + action = "renew" + + # 受影响角色 + affected_roles = [] + if current_pkg_id: + role_stmt = select(RoleModel).where(RoleModel.tenant_id == tenant_id) + r_result = await auth.db.execute(role_stmt) + affected_roles = [r.name for r in r_result.scalars().all()] + + return PackagePreviewOut( + current_package=current_pkg.name if current_pkg else "", + target_package=target_pkg.name, + action=action, + amount=target_pkg.price if hasattr(target_pkg, "price") else 0, + period=target_pkg.period if hasattr(target_pkg, "period") else "month", + gained_menus=gained_menus, + lost_menus=lost_menus, + affected_roles=affected_roles, + affected_users=0, + ) + + +async def create_self_order( + auth: AuthSchema, tenant_id: int, data: SelfOrderCreate +) -> SelfOrderOut: + """创建自助订单""" + tenant = await auth.db.get(TenantModel, tenant_id) + if not tenant: + raise CustomException(msg="租户不存在") + if tenant.status not in (0, 1, 2): + raise CustomException(msg="租户状态不允许操作") + + pkg = await auth.db.get(PackageModel, data.package_id) + if not pkg or pkg.status == 1: + raise CustomException(msg="套餐不可用") + + amount = pkg.price if hasattr(pkg, "price") else 0 + + from app.api.v1.module_platform.order.crud import OrderCRUD + from app.api.v1.module_platform.order.schema import ( + OrderCreateInternalSchema, + OrderUpdateInternalSchema, + ) + from app.api.v1.module_platform.order.service import _generate_order_no + + order = await OrderCRUD(auth).create( + OrderCreateInternalSchema( + order_no=_generate_order_no(), + tenant_id=tenant_id, + package_id=data.package_id, + order_type=data.order_type, + amount=amount, + expire_time=datetime.now() + timedelta(minutes=15), + ) + ) + await auth.db.flush() + + # 免费订单自动激活 + if amount == 0: + await OrderCRUD(auth).update( + order.id, + OrderUpdateInternalSchema(status=1, pay_method="free", pay_time=datetime.now()), + ) + from app.api.v1.module_platform.order.service import PaymentService + await PaymentService._activate_tenant_package(auth, order) + + logger.info(f"自助订单创建: order_no={order.order_no} tenant={tenant_id} amount={amount}") + return SelfOrderOut( + order_id=order.id, + order_no=order.order_no, + amount=amount, + need_pay=amount > 0, + ) + + +async def create_plugin_purchase_order( + auth: AuthSchema, tenant_id: int, data: PluginPurchaseCreate +) -> SelfOrderOut: + """创建插件购买订单（复用套餐订单流程）""" + from app.api.v1.module_platform.order.schema import OrderCreateSchema + from app.api.v1.module_platform.order.service import OrderService + from app.api.v1.module_platform.plugin.model import PluginModel, TenantPluginModel + + # 校验插件存在且可用 + plugin = await auth.db.get(PluginModel, data.plugin_id) + if not plugin or plugin.status == 1: + raise CustomException(msg="插件不可用") + + if getattr(plugin, "price", 0) == 0: + raise CustomException(msg="免费插件可直接安装，无需购买") + + # 校验未重复购买 + existing = await auth.db.execute( + select(TenantPluginModel).where( + TenantPluginModel.tenant_id == tenant_id, + TenantPluginModel.plugin_id == data.plugin_id, + ).limit(1) + ) + tp = existing.scalar_one_or_none() + if tp and tp.purchased == "1": + raise CustomException(msg="您已购买此插件，可直接安装") + + order_data = OrderCreateSchema( + tenant_id=tenant_id, + package_id=None, + plugin_id=data.plugin_id, + order_type="plugin", + pay_method=data.pay_method, + ) + result = await OrderService.create_order(auth, order_data) + + logger.info(f"插件购买订单创建: order_no={result.order_no} plugin={plugin.name}") + return SelfOrderOut( + order_id=result.id, + order_no=result.order_no, + amount=result.amount, + need_pay=result.amount > 0, + ) + + +async def get_self_order_list( + auth: AuthSchema, + tenant_id: int, + page_no: int = 1, + page_size: int = 20, + order_by: list[dict] | None = None, +) -> SelfOrderListOut: + """我的订单列表""" + from sqlalchemy import func as sa_func + + from app.api.v1.module_platform.order.model import OrderModel + + stmt = ( + select(OrderModel) + .where(OrderModel.tenant_id == tenant_id) + .order_by(OrderModel.created_time.desc()) + .offset((page_no - 1) * page_size) + .limit(page_size) + ) + result = await auth.db.execute(stmt) + orders = result.scalars().all() + + # 查总数 + total = ( + await auth.db.execute( + select(sa_func.count(OrderModel.id)).where(OrderModel.tenant_id == tenant_id) + ) + ).scalar() or 0 + + # 批量查询关联套餐，避免 N+1 + package_ids = [o.package_id for o in orders if o.package_id] + pkg_map: dict[int, str] = {} + if package_ids: + pkg_result = await auth.db.execute( + select(PackageModel.id, PackageModel.name).where(PackageModel.id.in_(package_ids)) + ) + pkg_map = {row[0]: row[1] for row in pkg_result.all()} + + items = [] + for o in orders: + pkg_name = pkg_map.get(o.package_id, "") if o.package_id else "" + items.append(SelfOrderListItem( + id=o.id, + order_no=o.order_no, + package_name=pkg_name, + order_type=o.order_type, + amount=o.amount, + status=o.status, + pay_method=o.pay_method, + pay_time=o.pay_time.isoformat() if o.pay_time else None, + created_at=o.created_time.isoformat() if o.created_time else None, + )) + + return SelfOrderListOut( + items=items, + total=total, + page_no=page_no, + page_size=page_size, + ) + + +async def get_self_order_detail( + auth: AuthSchema, tenant_id: int, order_id: int +) -> SelfOrderDetailOut: + """订单详情""" + from app.api.v1.module_platform.order.model import OrderModel + + stmt = select(OrderModel).where( + OrderModel.id == order_id, + OrderModel.tenant_id == tenant_id, + ) + result = await auth.db.execute(stmt) + order = result.scalar_one_or_none() + if not order: + raise CustomException(msg="订单不存在") + + pkg_name = "" + if order.package_id: + p = await auth.db.get(PackageModel, order.package_id) + if p: + pkg_name = p.name + + return SelfOrderDetailOut( + id=order.id, + order_no=order.order_no, + package_id=order.package_id, + package_name=pkg_name, + amount=order.amount, + order_type=order.order_type, + status=order.status, + pay_method=order.pay_method, + pay_time=order.pay_time.isoformat() if order.pay_time else None, + created_at=order.created_time.isoformat() if order.created_time else None, + ) + + +async def get_workspace_data(auth: AuthSchema, tenant_id: int) -> WorkspaceOut: + """获取租户工作台概览数据 + + 聚合返回：租户信息、当前套餐、配额用量、近期订单。 + """ + from app.api.v1.module_platform.package.model import PackageModel + from app.api.v1.module_platform.tenant.model import TenantModel + from app.api.v1.module_system.dept.model import DeptModel + from app.api.v1.module_system.role.model import RoleModel + from app.api.v1.module_system.user.model import UserModel + + tenant = await auth.db.get(TenantModel, tenant_id) + if not tenant: + return WorkspaceOut( + tenant=WorkspaceTenantInfo(id=0, name="", code="", status=0, status_label="未知"), + quota=WorkspaceQuotaInfo(), + ) + + # ── 套餐 ── + package = None + if tenant.package_id: + package = await auth.db.get(PackageModel, tenant.package_id) + + # ── 用量计数 ── + async def _count(model_cls) -> int: + stmt = select(func.count()).select_from(model_cls).where( + model_cls.tenant_id == tenant_id, + model_cls.is_deleted == False, + ) + return (await auth.db.execute(stmt)).scalar() or 0 + + user_count = await _count(UserModel) + role_count = await _count(RoleModel) + dept_count = await _count(DeptModel) + + # ── 到期状态 ── + now = datetime.now() + days_remaining = (tenant.end_time - now).days if tenant.end_time else 0 + + status_labels = { + "0": "正常", + "1": "宽限期", + "2": "已暂停", + "3": "已冻结", + "4": "已过期", + "5": "已归档", + } + + # ── 近期订单 ── + from app.api.v1.module_platform.order.model import OrderModel + + orders_stmt = ( + select(OrderModel) + .where(OrderModel.tenant_id == tenant_id) + .order_by(OrderModel.created_time.desc()) + .limit(5) + ) + orders_result = await auth.db.execute(orders_stmt) + recent_orders = [] + for o in orders_result.scalars().all(): + recent_orders.append(WorkspaceOrderItem( + id=o.id, + order_no=o.order_no, + amount=o.amount, + order_type=o.order_type, + status=o.status, + created_at=o.created_time.isoformat() if o.created_time else None, + )) + + return WorkspaceOut( + tenant=WorkspaceTenantInfo( + id=tenant.id, + name=tenant.name, + code=tenant.code, + status=tenant.status, + status_label=status_labels.get(str(tenant.status), "未知"), + start_time=tenant.start_time.isoformat() if tenant.start_time else None, + end_time=tenant.end_time.isoformat() if tenant.end_time else None, + days_remaining=max(days_remaining, 0), + ), + package=WorkspacePackageInfo( + id=package.id, + name=package.name, + price=package.price, + period=package.period, + max_users=package.max_users, + max_roles=package.max_roles, + max_depts=package.max_depts, + ) if package else None, + quota=WorkspaceQuotaInfo( + max_users=package.max_users if package else 0, + max_roles=package.max_roles if package else 0, + max_depts=package.max_depts if package else 0, + current_users=user_count, + current_roles=role_count, + current_depts=dept_count, + usage_percent=WorkspaceUsagePercent( + users=round(user_count / package.max_users * 100, 1) if package and package.max_users > 0 else 0, + roles=round(role_count / package.max_roles * 100, 1) if package and package.max_roles > 0 else 0, + depts=round(dept_count / package.max_depts * 100, 1) if package and package.max_depts > 0 else 0, + ), + ), + recent_orders=recent_orders, + ) + + +async def get_tenant_api_usage_today(auth: AuthSchema, tenant_id: int) -> dict: + """获取租户当日 API 用量汇总（已移除 api_usage 模块）""" + return {"today": {"request_count": 0, "error_count": 0, "total_duration_ms": 0}, "month": {"total_calls": 0}, "top_paths": []} + + +async def get_tenant_api_usage_daily(auth: AuthSchema, tenant_id: int, days: int = 7) -> dict: + """获取租户每日 API 用量（已移除 api_usage 模块）""" + return {"daily": []} diff --git a/backend/app/api/v1/module_platform/tenant/controller.py b/backend/app/api/v1/module_platform/tenant/controller.py index a884da04..b6a212d6 100644 --- a/backend/app/api/v1/module_platform/tenant/controller.py +++ b/backend/app/api/v1/module_platform/tenant/controller.py @@ -1,61 +1,79 @@ from typing import Annotated -from fastapi import APIRouter, Body, Depends, Path +from fastapi import APIRouter, Body, Depends, Path, Query from fastapi.responses import JSONResponse +from fastapi_cache import FastAPICache +from fastapi_cache.decorator import cache from redis.asyncio.client import Redis -from app.api.v1.module_system.auth.schema import AuthSchema from app.common.response import ResponseSchema, SuccessResponse from app.core.base_params import PaginationQueryParam -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable, PageResultSchema from app.core.dependencies import AuthPermission, redis_getter -from app.core.logger import log from app.core.router_class import OperationLogRoute from .schema import ( + PackageChangePreviewOut, TenantConfigItem, TenantConfigOutSchema, TenantCreateSchema, - TenantMenuSetSchema, TenantOutSchema, TenantQueryParam, - TenantQuotaOutSchema, - TenantQuotaUpdateSchema, + TenantRenewSchema, TenantUpdateSchema, TenantUserAddSchema, TenantUserOutSchema, ) from .service import TenantService -TenantRouter = APIRouter(route_class=OperationLogRoute, prefix="/tenant", tags=["租户管理"]) +TenantRouter = APIRouter(route_class=OperationLogRoute, prefix="/tenant", tags=["平台管理/租户管理"]) + +_TENANT_NS = "tenant" @TenantRouter.get( "/detail/{id}", summary="获取租户详情", - description="获取租户详情", response_model=ResponseSchema[TenantOutSchema], ) +@cache(expire=120, namespace=_TENANT_NS) async def get_obj_detail_controller( id: Annotated[int, Path(description="租户ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:tenant:query']))], ) -> JSONResponse: + """ + 获取租户详情 + + 参数: + - id (int): 租户 ID。 + + 返回: + - JSONResponse: 包含租户详情的 JSON 响应。 + """ result_dict = await TenantService.detail_service(id=id, auth=auth) - log.info(f"获取租户详情成功 {id}") return SuccessResponse(data=result_dict, msg="获取租户详情成功") @TenantRouter.get( "/list", summary="查询租户列表", - description="查询租户列表（分页）", - response_model=ResponseSchema[dict], + response_model=ResponseSchema[PageResultSchema[TenantOutSchema]], ) async def get_obj_list_controller( page: Annotated[PaginationQueryParam, Depends()], search: Annotated[TenantQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:tenant:query']))], ) -> JSONResponse: + """ + 查询租户列表 + + 参数: + - page (PaginationQueryParam): 分页查询参数。 + - search (TenantQueryParam): 查询筛选参数。 + + 返回: + - JSONResponse: 包含分页租户列表的 JSON 响应。 + """ order_by = [{"id": "asc"}] if page.order_by: order_by = page.order_by @@ -66,238 +84,323 @@ async def get_obj_list_controller( search=search, order_by=order_by, ) - log.info("查询租户列表成功") return SuccessResponse(data=result_dict, msg="查询租户列表成功") @TenantRouter.post( "/create", summary="创建租户", - description="创建租户", response_model=ResponseSchema[TenantOutSchema], ) async def create_obj_controller( data: TenantCreateSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:create"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:tenant:create']))], ) -> JSONResponse: + """ + 创建租户 + + 参数: + - data (TenantCreateSchema): 租户创建参数。 + + 返回: + - JSONResponse: 包含创建后的租户详情的 JSON 响应。 + """ result_dict = await TenantService.create_service(auth=auth, data=data) - log.info(f"创建租户成功: {result_dict.get('name')}") + await FastAPICache.clear(namespace=_TENANT_NS) return SuccessResponse(data=result_dict, msg="创建租户成功") @TenantRouter.put( "/update/{id}", summary="修改租户", - description="修改租户", response_model=ResponseSchema[TenantOutSchema], ) async def update_obj_controller( data: TenantUpdateSchema, id: Annotated[int, Path(description="租户ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:update"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:tenant:update']))], ) -> JSONResponse: + """ + 修改租户 + + 参数: + - id (int): 租户 ID。 + - data (TenantUpdateSchema): 租户更新参数。 + + 返回: + - JSONResponse: 包含更新后的租户详情的 JSON 响应。 + """ result_dict = await TenantService.update_service(auth=auth, id=id, data=data) - log.info(f"修改租户成功: {result_dict.get('name')}") + await FastAPICache.clear(namespace=_TENANT_NS) return SuccessResponse(data=result_dict, msg="修改租户成功") @TenantRouter.delete( "/delete", summary="删除租户", - description="删除租户", + response_model=ResponseSchema[None], ) async def delete_obj_controller( ids: Annotated[list[int], Body(..., description="ID列表")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:delete"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:tenant:delete']))], ) -> JSONResponse: + """ + 删除租户 + + 参数: + - ids (list[int]): 租户 ID 列表。 + + 返回: + - JSONResponse: 删除结果。 + """ await TenantService.delete_service(auth=auth, ids=ids) - log.info(f"删除租户成功: {ids}") + await FastAPICache.clear(namespace=_TENANT_NS) return SuccessResponse(msg="删除租户成功") @TenantRouter.patch( "/status/batch", summary="批量修改租户状态", - description="批量修改租户状态", + response_model=ResponseSchema[None], ) async def batch_set_available_obj_controller( data: BatchSetAvailable, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:patch"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:tenant:patch']))], ) -> JSONResponse: + """ + 批量修改租户状态 + + 参数: + - data (BatchSetAvailable): 批量状态设置参数。 + + 返回: + - JSONResponse: 操作结果。 + """ await TenantService.set_available_service(auth=auth, data=data) - log.info(f"批量修改租户状态成功: {data.ids}") + await FastAPICache.clear(namespace=_TENANT_NS) return SuccessResponse(msg="批量修改租户状态成功") @TenantRouter.put( "/status/{id}", summary="启/禁用租户", - description="修改单个租户的启用/禁用状态", + response_model=ResponseSchema[None], ) async def toggle_tenant_status_controller( id: Annotated[int, Path(description="租户ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:patch"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:tenant:patch']))], ) -> JSONResponse: + """ + 启/禁用租户 + + 参数: + - id (int): 租户 ID。 + + 返回: + - JSONResponse: 操作结果。 + """ await TenantService.toggle_status_service(auth=auth, id=id) - log.info(f"修改租户状态成功: {id}") + await FastAPICache.clear(namespace=_TENANT_NS) return SuccessResponse(msg="修改租户状态成功") @TenantRouter.get( "/{id}/users", summary="获取租户用户列表", - description="获取指定租户下的所有用户", response_model=ResponseSchema[list[TenantUserOutSchema]], ) +@cache(expire=120, namespace=_TENANT_NS) async def get_tenant_users_controller( id: Annotated[int, Path(description="租户ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:tenant:query']))], ) -> JSONResponse: + """ + 获取租户用户列表 + + 参数: + - id (int): 租户 ID。 + + 返回: + - JSONResponse: 包含租户用户列表的 JSON 响应。 + """ result = await TenantService.get_tenant_users_service(auth=auth, tenant_id=id) - log.info(f"获取租户用户列表成功: tenant_id={id}") return SuccessResponse(data=result, msg="获取租户用户列表成功") @TenantRouter.post( "/{id}/users", summary="向租户添加用户", - description="将指定用户添加到租户中", response_model=ResponseSchema[None], ) async def add_tenant_user_controller( id: Annotated[int, Path(description="租户ID")], data: TenantUserAddSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:create"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:tenant:create']))], ) -> JSONResponse: + """ + 向租户添加用户 + + 参数: + - id (int): 租户 ID。 + - data (TenantUserAddSchema): 用户添加参数。 + + 返回: + - JSONResponse: 操作结果。 + """ await TenantService.add_tenant_user_service(auth=auth, tenant_id=id, data=data) - log.info(f"向租户添加用户成功: tenant_id={id}, user_id={data.user_id}") + await FastAPICache.clear(namespace=_TENANT_NS) return SuccessResponse(msg="添加用户成功") @TenantRouter.delete( "/{id}/users/{uid}", summary="从租户移除用户", - description="将指定用户从租户中移除", response_model=ResponseSchema[None], ) async def remove_tenant_user_controller( id: Annotated[int, Path(description="租户ID")], uid: Annotated[int, Path(description="用户ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:delete"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:tenant:delete']))], ) -> JSONResponse: + """ + 从租户移除用户 + + 参数: + - id (int): 租户 ID。 + - uid (int): 用户 ID。 + + 返回: + - JSONResponse: 操作结果。 + """ await TenantService.remove_tenant_user_service(auth=auth, tenant_id=id, user_id=uid) - log.info(f"从租户移除用户成功: tenant_id={id}, user_id={uid}") + await FastAPICache.clear(namespace=_TENANT_NS) return SuccessResponse(msg="移除用户成功") - -# ============ P1: 配额管理 ============ - - -@TenantRouter.get( - "/{id}/quota", - summary="获取租户配额", - description="获取指定租户的资源配额信息", - response_model=ResponseSchema[TenantQuotaOutSchema], -) -async def get_tenant_quota_controller( - id: Annotated[int, Path(description="租户ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:query"]))], -) -> JSONResponse: - result = await TenantService.get_quota_service(auth=auth, tenant_id=id) - return SuccessResponse(data=result, msg="获取租户配额成功") - - -@TenantRouter.put( - "/{id}/quota", - summary="修改租户配额", - description="修改指定租户的资源配额（需超级管理员权限）", - response_model=ResponseSchema[TenantQuotaOutSchema], -) -async def update_tenant_quota_controller( - id: Annotated[int, Path(description="租户ID")], - data: TenantQuotaUpdateSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:update"]))], -) -> JSONResponse: - result = await TenantService.update_quota_service(auth=auth, tenant_id=id, data=data) - return SuccessResponse(data=result, msg="修改租户配额成功") - - # ============ P1: 租户配置 ============ @TenantRouter.get( "/{id}/config", summary="获取租户配置", - description="获取指定租户的个性化配置", response_model=ResponseSchema[list[TenantConfigOutSchema]], ) async def get_tenant_config_controller( id: Annotated[int, Path(description="租户ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:tenant:query']))], ) -> JSONResponse: - result = await TenantService.get_config_service(auth=auth, tenant_id=id) + """ + 获取租户配置 + + 参数: + - id (int): 租户 ID。 + + 返回: + - JSONResponse: 包含租户配置列表的 JSON 响应。 + """ + result = await TenantService.get_config_items_service(auth=auth, tenant_id=id) return SuccessResponse(data=result, msg="获取租户配置成功") @TenantRouter.get( "/{id}/config/info", summary="获取租户配置（公开-缓存）", - description="从 Redis 缓存获取租户个性化配置，无需登录（供登录页等场景使用）", response_model=ResponseSchema[list[TenantConfigOutSchema]], ) async def get_tenant_config_info_controller( id: Annotated[int, Path(description="租户ID")], redis: Annotated[Redis, Depends(redis_getter)], ) -> JSONResponse: - result = await TenantService.get_config_cache_service(redis=redis, tenant_id=id) + """ + 获取租户配置（公开-缓存） + + 参数: + - id (int): 租户 ID。 + + 返回: + - JSONResponse: 包含租户配置列表的 JSON 响应。 + """ + result = await TenantService.get_config_cache_items_service(redis=redis, tenant_id=id) return SuccessResponse(data=result, msg="获取租户配置成功") @TenantRouter.put( "/{id}/config", summary="更新租户配置", - description="批量更新租户的个性化配置", response_model=ResponseSchema[list[TenantConfigOutSchema]], ) async def update_tenant_config_controller( id: Annotated[int, Path(description="租户ID")], data: Annotated[list[TenantConfigItem], Body(..., description="配置项列表")], redis: Annotated[Redis, Depends(redis_getter)], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:update"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:tenant:update']))], ) -> JSONResponse: + """ + 更新租户配置 + + 参数: + - id (int): 租户 ID。 + - data (list[TenantConfigItem]): 配置项列表。 + + 返回: + - JSONResponse: 包含更新后的配置列表的 JSON 响应。 + """ result = await TenantService.update_config_service( - auth=auth, redis=redis, tenant_id=id, items=data + auth=auth, redis=redis, tenant_id=id, config=data ) + await FastAPICache.clear(namespace=_TENANT_NS) return SuccessResponse(data=result, msg="更新租户配置成功") - -# ============ P1: 租户菜单权限 ============ - - -@TenantRouter.get( - "/{id}/menus", - summary="获取租户菜单权限", - description="获取指定租户有权限访问的菜单ID列表", - response_model=ResponseSchema[list[int]], -) -async def get_tenant_menus_controller( - id: Annotated[int, Path(description="租户ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:query"]))], -) -> JSONResponse: - result = await TenantService.get_menus_service(auth=auth, tenant_id=id) - return SuccessResponse(data=result, msg="获取租户菜单成功") +# ============ 续期 ============ @TenantRouter.put( - "/{id}/menus", - summary="设置租户菜单权限", - description="批量设置租户的菜单权限（先清空再写入，需超级管理员权限）", + "/renew/{id}", + summary="租户续期", + response_model=ResponseSchema[TenantOutSchema], ) -async def set_tenant_menus_controller( +async def renew_tenant_controller( id: Annotated[int, Path(description="租户ID")], - data: TenantMenuSetSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:tenant:update"]))], + data: TenantRenewSchema, + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:tenant:update']))], ) -> JSONResponse: - await TenantService.set_menus_service(auth=auth, tenant_id=id, data=data) - log.info(f"设置租户菜单权限成功: tenant_id={id}, count={len(data.menu_ids)}") - return SuccessResponse(msg="设置租户菜单权限成功") + """ + 租户续期 + + 参数: + - id (int): 租户 ID。 + - data (TenantRenewSchema): 续期时间参数。 + + 返回: + - JSONResponse: 包含续期后的租户详情的 JSON 响应。 + """ + result = await TenantService.renew_service(auth=auth, tenant_id=id, end_time=data.end_time) + await FastAPICache.clear(namespace=_TENANT_NS) + return SuccessResponse(data=result, msg="租户续期成功") + +# ============ 套餐变更预览 ============ + + +@TenantRouter.get( + "/{id}/package-change-preview", + summary="套餐变更影响预览", + response_model=ResponseSchema[PackageChangePreviewOut], +) +async def package_change_preview_controller( + id: Annotated[int, Path(description="租户ID")], + new_package_id: Annotated[int, Query(..., description="目标套餐ID")], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:tenant:query']))], +) -> JSONResponse: + """ + 套餐变更影响预览 + + 参数: + - id (int): 租户 ID。 + - new_package_id (int): 目标套餐 ID。 + + 返回: + - JSONResponse: 包含套餐变更影响预览的 JSON 响应。 + """ + result = await TenantService.package_change_preview_service( + auth=auth, tenant_id=id, new_package_id=new_package_id + ) + return SuccessResponse(data=result, msg="套餐变更预览成功") diff --git a/backend/app/api/v1/module_platform/tenant/crud.py b/backend/app/api/v1/module_platform/tenant/crud.py index 6e2ace6b..af7d9e1b 100644 --- a/backend/app/api/v1/module_platform/tenant/crud.py +++ b/backend/app/api/v1/module_platform/tenant/crud.py @@ -1,59 +1,12 @@ -from collections.abc import Sequence -from typing import Any - -from app.api.v1.module_system.auth.schema import AuthSchema from app.core.base_crud import CRUDBase +from app.core.base_schema import AuthSchema from .model import TenantModel -from .schema import TenantCreateSchema, TenantOutSchema, TenantUpdateSchema +from .schema import TenantCreateSchema, TenantUpdateSchema class TenantCRUD(CRUDBase[TenantModel, TenantCreateSchema, TenantUpdateSchema]): """租户数据层""" def __init__(self, auth: AuthSchema) -> None: - self.auth = auth super().__init__(model=TenantModel, auth=auth) - - async def get_by_id_crud( - self, id: int, preload: list[str | Any] | None = None - ) -> TenantModel | None: - return await self.get(id=id, preload=preload) - - async def get_list_crud( - self, - search: dict | None = None, - order_by: list[dict[str, str]] | None = None, - preload: list[str | Any] | None = None, - ) -> Sequence[TenantModel]: - return await self.list(search=search, order_by=order_by, preload=preload) - - async def page_crud( - self, - offset: int, - limit: int, - order_by: list[dict[str, str]] | None, - search: dict | None = None, - out_schema: type[TenantOutSchema] | None = None, - preload: list[str | Any] | None = None, - ) -> dict: - return await self.page( - offset=offset, - limit=limit, - order_by=order_by or [{"id": "asc"}], - search=search or {}, - out_schema=out_schema or TenantOutSchema, - preload=preload or [], - ) - - async def create_crud(self, data: TenantCreateSchema) -> TenantModel | None: - return await self.create(data=data) - - async def update_crud(self, id: int, data: TenantUpdateSchema) -> TenantModel | None: - return await self.update(id=id, data=data) - - async def delete_crud(self, ids: list[int]) -> None: - await self.delete(ids=ids) - - async def set_available_crud(self, ids: list[int], status: str) -> None: - await self.set(ids=ids, status=status) diff --git a/backend/app/api/v1/module_platform/tenant/model.py b/backend/app/api/v1/module_platform/tenant/model.py index 5e642d74..a012a44d 100644 --- a/backend/app/api/v1/module_platform/tenant/model.py +++ b/backend/app/api/v1/module_platform/tenant/model.py @@ -1,6 +1,6 @@ from datetime import datetime -from sqlalchemy import DateTime, ForeignKey, Integer, SmallInteger, String, Text, UniqueConstraint +from sqlalchemy import DateTime, ForeignKey, Integer, SmallInteger, String, UniqueConstraint from sqlalchemy.orm import Mapped, mapped_column, validates from app.common.enums import PermissionFilterStrategy @@ -11,9 +11,9 @@ class TenantModel(ModelMixin): """ 租户模型 - 单一大表设计 - - 系统租户(id=1)：平台管理，由超级管理员维护 - - 普通租户(id>1)：独立组织数据，通过业务表的 tenant_id 隔离 - - 配额字段直接集成到主表，简化结构便于管理 + - 系统租户(id=1)：平台管理，由超级管理员维护，不受套餐限制 + - 普通租户(id>1)：配额和菜单通过关联的 Package 控制 + - 配置字段直接集成到主表 """ __tablename__: str = "platform_tenant" @@ -55,19 +55,36 @@ class TenantModel(ModelMixin): end_time: Mapped[datetime | None] = mapped_column( DateTime, nullable=True, default=None, comment="结束时间" ) - # 配额字段 - 直接集成到主表 - max_users: Mapped[int] = mapped_column( - Integer, nullable=False, default=50, comment="最大用户数" + # ============ 租户配置字段（从 TenantConfigModel 合并）=========== + version: Mapped[str | None] = mapped_column( + String(20), nullable=True, default=None, comment="版本号" ) - max_roles: Mapped[int] = mapped_column( - Integer, nullable=False, default=20, comment="最大角色数" + favicon: Mapped[str | None] = mapped_column( + String(500), nullable=True, default=None, comment="favicon地址" ) - max_storage_mb: Mapped[int] = mapped_column( - Integer, nullable=False, default=500, comment="最大存储(MB)" + login_bg: Mapped[str | None] = mapped_column( + String(500), nullable=True, default=None, comment="登录背景地址" ) - max_depts: Mapped[int] = mapped_column( - Integer, nullable=False, default=50, comment="最大部门数" + copyright: Mapped[str | None] = mapped_column( + String(255), nullable=True, default=None, comment="版权信息" ) + keep_record: Mapped[str | None] = mapped_column( + String(100), nullable=True, default=None, comment="备案号" + ) + help_doc: Mapped[str | None] = mapped_column( + String(500), nullable=True, default=None, comment="帮助文档地址" + ) + privacy: Mapped[str | None] = mapped_column( + String(500), nullable=True, default=None, comment="隐私政策地址" + ) + clause: Mapped[str | None] = mapped_column( + String(500), nullable=True, default=None, comment="服务条款地址" + ) + git_code: Mapped[str | None] = mapped_column( + String(500), nullable=True, default=None, comment="源码地址" + ) + + # ── 关系 ═══════════════════════════════════════════ @validates("name") def validate_name(self, key: str, name: str) -> str: @@ -83,12 +100,6 @@ class TenantModel(ModelMixin): raise ValueError("编码只能包含字母和数字") return code - @validates("max_users", "max_roles", "max_storage_mb", "max_depts") - def validate_quota(self, key: str, value: int) -> int: - if value < 1: - raise ValueError(f"{key} 不能小于 1") - return value - class TenantUserModel(MappedBase): """ @@ -137,53 +148,3 @@ class TenantUserModel(MappedBase): nullable=False, comment="创建时间", ) - - -class TenantConfigModel(MappedBase): - """租户个性化配置模型 — 键值对存储""" - - __tablename__: str = "platform_tenant_config" - __table_args__ = ( - UniqueConstraint("tenant_id", "config_key", name="uq_tenant_config_key"), - {"comment": "租户配置表"}, - ) - - id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True, comment="主键ID") - tenant_id: Mapped[int] = mapped_column( - Integer, - ForeignKey("platform_tenant.id", ondelete="CASCADE", onupdate="CASCADE"), - nullable=False, - index=True, - comment="租户ID", - ) - config_key: Mapped[str] = mapped_column(String(100), nullable=False, comment="配置键") - config_value: Mapped[str | None] = mapped_column(Text, nullable=True, comment="配置值") - config_type: Mapped[str] = mapped_column( - String(20), nullable=False, default="string", comment="配置类型(string/json/int/bool)" - ) - - -class TenantMenuModel(MappedBase): - """租户菜单权限模型 — 控制租户可见的菜单项""" - - __tablename__: str = "platform_tenant_menu" - __table_args__ = ( - UniqueConstraint("tenant_id", "menu_id", name="uq_tenant_menu"), - {"comment": "租户菜单权限表"}, - ) - - id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True, comment="主键ID") - tenant_id: Mapped[int] = mapped_column( - Integer, - ForeignKey("platform_tenant.id", ondelete="CASCADE", onupdate="CASCADE"), - nullable=False, - index=True, - comment="租户ID", - ) - menu_id: Mapped[int] = mapped_column( - Integer, - ForeignKey("sys_menu.id", ondelete="CASCADE", onupdate="CASCADE"), - nullable=False, - index=True, - comment="菜单ID", - ) diff --git a/backend/app/api/v1/module_platform/tenant/schema.py b/backend/app/api/v1/module_platform/tenant/schema.py index 3d516cca..52a00c0c 100644 --- a/backend/app/api/v1/module_platform/tenant/schema.py +++ b/backend/app/api/v1/module_platform/tenant/schema.py @@ -1,3 +1,5 @@ +from dataclasses import dataclass + from fastapi import Query from pydantic import BaseModel, ConfigDict, Field, field_validator, model_validator @@ -11,8 +13,8 @@ class TenantCreateSchema(BaseModel): name: str = Field(..., min_length=1, max_length=100, description="租户名称") code: str = Field(..., min_length=2, max_length=100, description="租户编码") - status: str = Field(default="0", max_length=1, description="状态(0:正常 1:禁用)") - description: str | None = Field(default=None, max_length=255, description="描述") + status: int = Field(default=0, ge=0, le=1, description="状态(0:正常 1:禁用)") + description: str | None = Field(default=None, description="描述") start_time: DateTimeStr | None = Field(default=None, description="开始时间") end_time: DateTimeStr | None = Field(default=None, description="结束时间") contact_name: str | None = Field(default=None, max_length=64, description="联系人姓名") @@ -23,6 +25,15 @@ class TenantCreateSchema(BaseModel): logo_url: str | None = Field(default=None, max_length=500, description="Logo URL") sort: int = Field(default=0, ge=0, description="排序") package_id: int | None = Field(default=None, gt=0, description="关联套餐ID") + version: str | None = Field(default=None, max_length=20, description="版本号") + favicon: str | None = Field(default=None, max_length=500, description="favicon地址") + login_bg: str | None = Field(default=None, max_length=500, description="登录背景地址") + copyright: str | None = Field(default=None, max_length=255, description="版权信息") + keep_record: str | None = Field(default=None, max_length=100, description="备案号") + help_doc: str | None = Field(default=None, max_length=500, description="帮助文档地址") + privacy: str | None = Field(default=None, max_length=500, description="隐私政策地址") + clause: str | None = Field(default=None, max_length=500, description="服务条款地址") + git_code: str | None = Field(default=None, max_length=500, description="源码地址") @field_validator("name") @classmethod @@ -44,8 +55,8 @@ class TenantCreateSchema(BaseModel): @field_validator("status") @classmethod - def _validate_status(cls, v: str) -> str: - if v not in {"0", "1"}: + def _validate_status(cls, v: int) -> int: + if v not in {0, 1}: raise ValueError("状态仅支持 0(正常) 或 1(禁用)") return v @@ -68,13 +79,13 @@ class TenantCreateSchema(BaseModel): return self -class TenantUpdateSchema(BaseModel): +class TenantUpdateSchema(TenantCreateSchema): """更新租户""" - name: str | None = Field(default=None, max_length=100, description="租户名称") - code: str | None = Field(default=None, max_length=100, description="租户编码") - status: str | None = Field(default=None, max_length=1, description="状态(0:正常 1:禁用)") - description: str | None = Field(default=None, max_length=255, description="描述") + name: str | None = Field(default=None, max_length=100, description="租户名称") # type: ignore[assignment] + code: str | None = Field(default=None, max_length=100, description="租户编码") # type: ignore[assignment] + status: int | None = Field(default=None, ge=0, le=1, description="状态(0:正常 1:禁用)") + description: str | None = Field(default=None, description="描述") start_time: DateTimeStr | None = Field(default=None, description="开始时间") end_time: DateTimeStr | None = Field(default=None, description="结束时间") contact_name: str | None = Field(default=None, max_length=64, description="联系人姓名") @@ -85,6 +96,15 @@ class TenantUpdateSchema(BaseModel): logo_url: str | None = Field(default=None, max_length=500, description="Logo URL") sort: int | None = Field(default=None, ge=0, description="排序") package_id: int | None = Field(default=None, gt=0, description="关联套餐ID") + version: str | None = Field(default=None, max_length=20, description="版本号") + favicon: str | None = Field(default=None, max_length=500, description="favicon地址") + login_bg: str | None = Field(default=None, max_length=500, description="登录背景地址") + copyright: str | None = Field(default=None, max_length=255, description="版权信息") + keep_record: str | None = Field(default=None, max_length=100, description="备案号") + help_doc: str | None = Field(default=None, max_length=500, description="帮助文档地址") + privacy: str | None = Field(default=None, max_length=500, description="隐私政策地址") + clause: str | None = Field(default=None, max_length=500, description="服务条款地址") + git_code: str | None = Field(default=None, max_length=500, description="源码地址") @field_validator("code") @classmethod @@ -98,10 +118,10 @@ class TenantUpdateSchema(BaseModel): @field_validator("status") @classmethod - def _validate_status(cls, v: str | None) -> str | None: + def _validate_status(cls, v: int | None) -> int | None: if v is None: return v - if v not in {"0", "1"}: + if v not in {0, 1}: raise ValueError("状态仅支持 0(正常) 或 1(禁用)") return v @@ -130,6 +150,7 @@ class TenantOutSchema(TenantCreateSchema, BaseSchema): model_config = ConfigDict(from_attributes=True) +@dataclass class TenantQueryParam: """租户查询参数""" @@ -191,61 +212,52 @@ class TenantUserOutSchema(BaseModel): name: str = Field(default="", description="用户姓名") -# ============ P1: 配额管理 ============ - - -class TenantQuotaOutSchema(BaseModel): - """租户配额响应""" - - model_config = ConfigDict(from_attributes=True) - - tenant_id: int - max_users: int - max_roles: int - max_storage_mb: int - max_depts: int - - -class TenantQuotaUpdateSchema(BaseModel): - """租户配额更新""" - - max_users: int | None = Field(default=None, ge=0, description="最大用户数") - max_roles: int | None = Field(default=None, ge=0, description="最大角色数") - max_storage_mb: int | None = Field(default=None, ge=0, description="最大存储(MB)") - max_depts: int | None = Field(default=None, ge=0, description="最大部门数") - - # ============ P1: 租户配置 ============ class TenantConfigItem(BaseModel): - """单个配置项""" + """租户配置项""" - config_key: str = Field(..., min_length=1, max_length=100, description="配置键") - config_value: str = Field(..., max_length=65535, description="配置值") - config_type: str = Field(default="string", max_length=20, description="配置类型(string/json/int/bool)") - - @field_validator("config_type") - @classmethod - def _validate_config_type(cls, v: str) -> str: - if v not in {"string", "json", "int", "bool"}: - raise ValueError("配置类型仅支持 string、json、int、bool") - return v + key: str = Field(..., description="配置键") + value: str | None = Field(default=None, description="配置值") -class TenantConfigOutSchema(TenantConfigItem): +class TenantConfigOutSchema(BaseModel): """租户配置响应""" model_config = ConfigDict(from_attributes=True) - id: int - tenant_id: int + config_key: str = Field(..., description="配置键") + config_value: str | None = Field(default=None, description="配置值") -# ============ P1: 租户菜单 ============ +# ============ 续期 ============ -class TenantMenuSetSchema(BaseModel): - """批量设置租户菜单权限""" +class TenantRenewSchema(BaseModel): + """租户续期""" - menu_ids: list[int] = Field(..., description="菜单ID列表") + end_time: DateTimeStr = Field(..., description="新的结束时间") + + @model_validator(mode="after") + def _validate_end_time(self): + from datetime import datetime + + if self.end_time <= datetime.now(): + raise ValueError("续期时间必须晚于当前时间") + return self + + +# ============ 套餐变更预览 ============ + + +class PackageChangePreviewOut(BaseModel): + """套餐变更影响预览响应""" + + new_package_id: int = Field(..., description="新套餐ID") + new_package_name: str = Field(default="", description="新套餐名称") + affected_roles: list[dict] = Field(default_factory=list, description="受影响的角色列表（名称、用户数）") + removed_menus: list[dict] = Field(default_factory=list, description="将被移除的菜单清单（名称、路径）") + added_menus: list[dict] = Field(default_factory=list, description="新增的菜单清单（名称、路径）") + quota_changes: dict = Field(default_factory=dict, description="配额变化对比") + total_affected_users: int = Field(default=0, description="受影响用户数总计") diff --git a/backend/app/api/v1/module_platform/tenant/service.py b/backend/app/api/v1/module_platform/tenant/service.py index 66f85621..632fee84 100644 --- a/backend/app/api/v1/module_platform/tenant/service.py +++ b/backend/app/api/v1/module_platform/tenant/service.py @@ -5,34 +5,21 @@ import string import sqlalchemy as sa from redis.asyncio.client import Redis -from app.api.v1.module_system.auth.schema import AuthSchema -from app.api.v1.module_system.dept.crud import DeptCRUD -from app.api.v1.module_system.position.crud import PositionCRUD -from app.api.v1.module_system.role.crud import RoleCRUD -from app.api.v1.module_system.user.crud import UserCRUD from app.common.enums import RedisInitKeyConfig -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable from app.core.exceptions import CustomException -from app.core.logger import log +from app.core.logger import logger from app.core.redis_crud import RedisCURD from app.utils.hash_bcrpy_util import PwdUtil from .crud import TenantCRUD -from .model import ( - TenantConfigModel, - TenantMenuModel, - TenantModel, - TenantUserModel, -) +from .model import TenantModel, TenantUserModel from .schema import ( - TenantConfigItem, + PackageChangePreviewOut, TenantConfigOutSchema, TenantCreateSchema, - TenantMenuSetSchema, TenantOutSchema, TenantQueryParam, - TenantQuotaOutSchema, - TenantQuotaUpdateSchema, TenantUpdateSchema, TenantUserAddSchema, TenantUserOutSchema, @@ -43,11 +30,11 @@ class TenantService: """租户管理模块服务层""" @classmethod - async def detail_service(cls, auth: AuthSchema, id: int) -> dict: - obj = await TenantCRUD(auth).get_by_id_crud(id=id) + async def detail_service(cls, auth: AuthSchema, id: int) -> TenantOutSchema: + obj = await TenantCRUD(auth).get(id=id) if not obj: raise CustomException(msg="租户不存在") - result = TenantOutSchema.model_validate(obj).model_dump() + result = TenantOutSchema.model_validate(obj) return result @classmethod @@ -59,7 +46,7 @@ class TenantService: search: TenantQueryParam | None = None, order_by: list[dict[str, str]] | None = None, ) -> dict: - return await TenantCRUD(auth).page_crud( + return await TenantCRUD(auth).page( offset=(page_no - 1) * page_size, limit=page_size, order_by=order_by or [{"id": "asc"}], @@ -68,13 +55,13 @@ class TenantService: ) @classmethod - async def create_service(cls, auth: AuthSchema, data: TenantCreateSchema) -> dict: + async def create_service(cls, auth: AuthSchema, data: TenantCreateSchema) -> TenantOutSchema: if await TenantCRUD(auth).get(name=data.name): raise CustomException(msg="创建失败，名称已存在") if await TenantCRUD(auth).get(code=data.code): raise CustomException(msg="创建失败，编码已存在") - tenant_obj = await TenantCRUD(auth).create_crud(data=data) + tenant_obj = await TenantCRUD(auth).create(data=data) if not tenant_obj: raise CustomException(msg="创建租户失败") @@ -83,7 +70,9 @@ class TenantService: # 2. 检查用户名是否已存在 # 3. 创建初始管理员用户 username = f"{tenant_obj.code}_admin" - if await UserCRUD(auth).get_by_username_crud(username=username): + from app.api.v1.module_system.user.crud import UserCRUD + + if await UserCRUD(auth).get(username=username): raise CustomException(msg=f"初始管理员用户名已存在: {username}，请更换租户编码后重试") password_length = 12 @@ -104,21 +93,21 @@ class TenantService: except CustomException: raise except Exception as e: - log.error(f"为租户[{tenant_obj.name}]创建初始管理员失败: {e!s}") + logger.error(f"为租户[{tenant_obj.name}]创建初始管理员失败: {e!s}") raise CustomException(msg="创建租户初始管理员失败") - log.info( + logger.info( f"为租户[{tenant_obj.name}]创建初始管理员成功，用户名: {username}，临时密码: {password}" ) await auth.db.refresh(tenant_obj) - result = TenantOutSchema.model_validate(tenant_obj).model_dump() + result = TenantOutSchema.model_validate(tenant_obj) return result @classmethod - async def update_service(cls, auth: AuthSchema, id: int, data: TenantUpdateSchema) -> dict: - obj = await TenantCRUD(auth).get_by_id_crud(id=id) + async def update_service(cls, auth: AuthSchema, id: int, data: TenantUpdateSchema) -> TenantOutSchema: + obj = await TenantCRUD(auth).get(id=id) if not obj: raise CustomException(msg="租户不存在") @@ -127,7 +116,7 @@ class TenantService: if id == 1: if data.code is not None and data.code != obj.code: raise CustomException(msg="系统租户编码不可修改") - if data.status is not None and data.status == "1": + if data.status is not None and data.status == 1: raise CustomException(msg="系统租户不允许禁用") # 套餐变更：仅超管可操作，防止租户管理员自行升级/降级套餐 @@ -144,7 +133,7 @@ class TenantService: if exist and exist.id != id: raise CustomException(msg="更新失败，编码重复") - updated = await TenantCRUD(auth).update_crud(id=id, data=data) + updated = await TenantCRUD(auth).update(id=id, data=data) if not updated: raise CustomException(msg="更新失败") @@ -169,12 +158,12 @@ class TenantService: ) ) await auth.db.flush() - log.info( + logger.info( f"租户[{id}]套餐变更：已清理角色中不再可用的菜单关联, " f"available_menus={len(available_ids)}, roles_affected={len(tenant_role_ids)}" ) - result = TenantOutSchema.model_validate(updated).model_dump() + result = TenantOutSchema.model_validate(updated) return result @classmethod @@ -184,9 +173,14 @@ class TenantService: if 1 in ids: raise CustomException(msg="系统租户不允许删除") for id in ids: - obj = await TenantCRUD(auth).get_by_id_crud(id=id) + obj = await TenantCRUD(auth).get(id=id) if not obj: continue + from app.api.v1.module_system.dept.crud import DeptCRUD + from app.api.v1.module_system.position.crud import PositionCRUD + from app.api.v1.module_system.role.crud import RoleCRUD + from app.api.v1.module_system.user.crud import UserCRUD + for tid in ids: reasons: list[str] = [] if await UserCRUD(auth).list(search={"tenant_id": tid}): @@ -198,30 +192,29 @@ class TenantService: if await PositionCRUD(auth).list(search={"tenant_id": tid}): reasons.append("岗位") if reasons: - raise CustomException( - msg=f"租户 ID={tid} 下仍有关联数据（{','.join(reasons)}），请先清理后再删除" - ) - await TenantCRUD(auth).delete_crud(ids=ids) + raise CustomException(msg=f"租户下已存在{'/'.join(reasons)}，操作失败") + + await TenantCRUD(auth).delete(ids=ids) @classmethod async def set_available_service(cls, auth: AuthSchema, data: BatchSetAvailable) -> None: - if data.status == "1" and 1 in data.ids: + if data.status == 1 and 1 in data.ids: raise CustomException(msg="系统租户不允许禁用") - await TenantCRUD(auth).set_available_crud(ids=data.ids, status=data.status) + await TenantCRUD(auth).set(ids=data.ids, status=data.status) @classmethod async def toggle_status_service(cls, auth: AuthSchema, id: int) -> None: """切换单个租户的启用/禁用状态""" - obj = await TenantCRUD(auth).get_by_id_crud(id=id) + obj = await TenantCRUD(auth).get(id=id) if not obj: raise CustomException(msg="租户不存在") if id == 1: raise CustomException(msg="系统租户不允许禁用") - new_status = "0" if obj.status == "1" else "1" - await TenantCRUD(auth).set_available_crud(ids=[id], status=new_status) + new_status = 0 if obj.status == 1 else 1 + await TenantCRUD(auth).set(ids=[id], status=new_status) @classmethod - async def get_tenant_users_service(cls, auth: AuthSchema, tenant_id: int) -> list[dict]: + async def get_tenant_users_service(cls, auth: AuthSchema, tenant_id: int) -> list[TenantUserOutSchema]: """获取租户下的用户列表""" from sqlalchemy import select @@ -248,7 +241,7 @@ class TenantService: create_time=tu.create_time, username=u.username, name=u.name, - ).model_dump() + ) ) return users @@ -258,14 +251,14 @@ class TenantService: ) -> None: """向租户添加用户""" # 验证租户存在 - tenant = await TenantCRUD(auth).get_by_id_crud(id=tenant_id) + tenant = await TenantCRUD(auth).get(id=tenant_id) if not tenant: raise CustomException(msg="租户不存在") # 验证用户存在 from app.api.v1.module_system.user.crud import UserCRUD - user = await UserCRUD(auth).get_by_id_crud(id=data.user_id) + user = await UserCRUD(auth).get(id=data.user_id) if not user: raise CustomException(msg="用户不存在") @@ -316,7 +309,7 @@ class TenantService: auth.db.add(tu) await auth.db.flush() - log.info(f"向租户[{tenant.name}]添加用户[{user.username}]成功, role={data.role}") + logger.info(f"向租户[{tenant.name}]添加用户[{user.username}]成功, role={data.role}") @classmethod async def remove_tenant_user_service( @@ -356,72 +349,87 @@ class TenantService: await auth.db.delete(tu) await auth.db.flush() - log.info(f"从租户[{tenant_id}]移除用户[{user_id}]成功") + logger.info(f"从租户[{tenant_id}]移除用户[{user_id}]成功") # ============ P1: 配额管理 ============ + # 配额（max_users / max_roles / max_depts / max_storage_mb）由关联的 Package 控制 + # 系统租户 (id=1) 不受配额限制，普通租户从 package_id 对应的套餐读取配额 @classmethod async def get_quota_service(cls, auth: AuthSchema, tenant_id: int) -> dict: - """获取租户配额（从租户主表读取）""" - tenant = await TenantCRUD(auth).get_by_id_crud(id=tenant_id) + """获取租户配额（从关联套餐读取，系统租户返回无限配额）""" + if tenant_id == 1: + return { + "tenant_id": 1, + "max_users": 999999, + "max_roles": 999999, + "max_storage_mb": 999999, + "max_depts": 999999, + "package_name": "系统租户(无限)", + } + tenant = await TenantCRUD(auth).get(id=tenant_id) if not tenant: raise CustomException(msg="租户不存在") - return TenantQuotaOutSchema( - tenant_id=tenant.id, - max_users=tenant.max_users, - max_roles=tenant.max_roles, - max_storage_mb=tenant.max_storage_mb, - max_depts=tenant.max_depts, - ).model_dump() - - @classmethod - async def update_quota_service( - cls, auth: AuthSchema, tenant_id: int, data: TenantQuotaUpdateSchema - ) -> dict: - """更新租户配额（直接更新租户主表）""" - tenant = await TenantCRUD(auth).get_by_id_crud(id=tenant_id) - if not tenant: - raise CustomException(msg="租户不存在") - - update_data = data.model_dump(exclude_unset=True) - for k, v in update_data.items(): - setattr(tenant, k, v) - await auth.db.flush() - log.info(f"租户[{tenant_id}]配额已更新: {update_data}") - return TenantQuotaOutSchema( - tenant_id=tenant.id, - max_users=tenant.max_users, - max_roles=tenant.max_roles, - max_storage_mb=tenant.max_storage_mb, - max_depts=tenant.max_depts, - ).model_dump() + if not tenant.package_id: + return { + "tenant_id": tenant.id, + "max_users": 0, + "max_roles": 0, + "max_storage_mb": 0, + "max_depts": 0, + "package_name": "未绑定套餐", + } + from app.api.v1.module_platform.package.crud import PackageCRUD + pkg = await PackageCRUD(auth).get(id=tenant.package_id) + if not pkg: + return { + "tenant_id": tenant.id, "max_users": 0, "max_roles": 0, + "max_storage_mb": 0, "max_depts": 0, "package_name": "套餐已删除", + } + return { + "tenant_id": tenant.id, + "max_users": pkg.max_users, + "max_roles": pkg.max_roles, + "max_storage_mb": getattr(pkg, "max_storage_mb", 0), + "max_depts": pkg.max_depts, + "package_name": pkg.name, + } @classmethod async def check_quota_service( cls, auth: AuthSchema, tenant_id: int, - resource_type: str, # "user"/"role"/"dept" + resource_type: str, ) -> None: - """检查租户配额是否充足，不足时抛出异常""" + """检查租户配额是否充足，不足时抛出异常（系统租户跳过检查）""" + if tenant_id == 1: + return from sqlalchemy import func, select - tenant = await TenantCRUD(auth).get_by_id_crud(id=tenant_id) - if not tenant: - raise CustomException(msg="租户不存在") + tenant = await TenantCRUD(auth).get(id=tenant_id) + if not tenant or not tenant.package_id: + return + + from app.api.v1.module_platform.package.crud import PackageCRUD + pkg = await PackageCRUD(auth).get(id=tenant.package_id) + if not pkg: + return field_map = { "user": "max_users", "role": "max_roles", "dept": "max_depts", + "storage": "max_storage_mb", } if resource_type not in field_map: return max_field = field_map[resource_type] - max_limit = getattr(tenant, max_field, 0) + max_limit = getattr(pkg, max_field, None) + if max_limit is None or max_limit == 0: + return - # 根据资源类型动态获取当前数量 if resource_type == "user": from app.api.v1.module_system.user.model import UserModel count_stmt = select(func.count()).select_from(UserModel).where( @@ -440,30 +448,46 @@ class TenantService: DeptModel.tenant_id == tenant_id, DeptModel.is_deleted.is_(False), ) + elif resource_type == "storage": + # storage 的实际容量校验在文件上传时进行，此处仅检查是否有配额 + return result = await auth.db.execute(count_stmt) current_count = result.scalar() or 0 - if max_limit > 0 and current_count >= max_limit: + if current_count >= max_limit: resource_labels = {"user": "用户", "role": "角色", "dept": "部门"} raise CustomException( - msg=f"租户{resource_labels.get(resource_type, resource_type)}数量已达上限（{max_limit}），无法继续创建" + msg=f"租户{resource_labels.get(resource_type, resource_type)}数量已达套餐上限（{max_limit}），无法继续创建" ) - # ============ P1: 租户配置 ============ + # ============ P1: 租户配置（已合并到主表） ============ @classmethod - async def get_config_service(cls, auth: AuthSchema, tenant_id: int) -> list[dict]: - """获取租户所有配置（带 Redis 缓存）""" - from sqlalchemy import select + async def get_config_service(cls, auth: AuthSchema, tenant_id: int) -> dict: + """获取租户所有配置（从租户主表读取，返回原始 dict 供内部使用）""" + tenant = await TenantCRUD(auth).get(id=tenant_id) + if not tenant: + raise CustomException(msg="租户不存在") - stmt = select(TenantConfigModel).where(TenantConfigModel.tenant_id == tenant_id) - result = await auth.db.execute(stmt) - configs = result.scalars().all() - return [TenantConfigOutSchema.model_validate(c).model_dump() for c in configs] + config_fields = [ + "name", "description", "version", "logo_url", "favicon", "login_bg", + "copyright", "keep_record", "help_doc", "privacy", "clause", "git_code" + ] + config = {field: getattr(tenant, field, None) for field in config_fields} + return config @classmethod - async def get_config_cache_service(cls, redis: Redis, tenant_id: int) -> list[dict]: + async def get_config_items_service(cls, auth: AuthSchema, tenant_id: int) -> list[TenantConfigOutSchema]: + """获取租户所有配置（对外接口，返回结构化列表）""" + config = await cls.get_config_service(auth, tenant_id) + return [ + TenantConfigOutSchema(config_key=k, config_value=str(v) if v is not None else None) + for k, v in config.items() + ] + + @classmethod + async def get_config_cache_service(cls, redis: Redis, tenant_id: int) -> dict: """ 从 Redis 缓存获取租户配置，缓存未命中则从 DB 加载并回写缓存 @@ -472,127 +496,86 @@ class TenantService: - tenant_id (int): 租户ID 返回: - - list[dict]: 租户配置列表 + - dict: 租户配置字典 """ - redis_keys = await RedisCURD(redis).get_keys( - f"{RedisInitKeyConfig.TENANT_CONFIG.key}:{tenant_id}:*" - ) - redis_configs = await RedisCURD(redis).mget(redis_keys) - configs = [] - for config in redis_configs: - if not config: - continue + redis_key = f"{RedisInitKeyConfig.TENANT_CONFIG.key}:{tenant_id}" + redis_config = await RedisCURD(redis).get(key=redis_key) + + if redis_config: try: - configs.append(json.loads(config)) + return json.loads(redis_config) except Exception as e: - log.error(f"解析租户配置数据失败: {e}") - continue + logger.error(f"解析租户配置数据失败: {e}") - if not configs: - log.info(f"Redis 中没有租户[{tenant_id}]配置数据，从数据库中加载") - from app.core.database import async_db_session + logger.info(f"Redis 中没有租户[{tenant_id}]配置数据，从数据库中加载") + from app.core.database import async_db_session - async with async_db_session() as session: - async with session.begin(): - from app.api.v1.module_system.auth.schema import AuthSchema + async with async_db_session() as session: + async with session.begin(): + from app.core.base_schema import AuthSchema - auth = AuthSchema(db=session, check_data_scope=False) - configs = await cls.get_config_service(auth, tenant_id) - await cls._sync_configs_to_redis(redis, tenant_id, configs) - log.info(f"✅ 已从数据库加载 {len(configs)} 条租户配置到缓存") + auth = AuthSchema(db=session, check_data_scope=False) + config = await cls.get_config_service(auth, tenant_id) + await cls._sync_configs_to_redis(redis, tenant_id, config) + logger.info("✅ 已从数据库加载租户配置到缓存") - return configs + return config @classmethod - async def _sync_configs_to_redis( - cls, redis: Redis, tenant_id: int, configs: list[dict] - ) -> None: - """将租户配置列表批量写入 Redis 缓存""" - for cfg in configs: - redis_key = ( - f"{RedisInitKeyConfig.TENANT_CONFIG.key}:{tenant_id}:{cfg.get('config_key')}" - ) - value = json.dumps(cfg, ensure_ascii=False) - await RedisCURD(redis).set(key=redis_key, value=value, expire=None) + async def get_config_cache_items_service(cls, redis: Redis, tenant_id: int) -> list[TenantConfigOutSchema]: + """获取租户缓存配置（对外接口，返回结构化列表）""" + config = await cls.get_config_cache_service(redis, tenant_id) + return [ + TenantConfigOutSchema(config_key=k, config_value=str(v) if v is not None else None) + for k, v in config.items() + ] @classmethod - async def _del_configs_from_redis(cls, redis: Redis, tenant_id: int, keys: list[str]) -> None: + async def _sync_configs_to_redis(cls, redis: Redis, tenant_id: int, config: dict) -> None: + """将租户配置写入 Redis 缓存""" + redis_key = f"{RedisInitKeyConfig.TENANT_CONFIG.key}:{tenant_id}" + value = json.dumps(config, ensure_ascii=False) + await RedisCURD(redis).set(key=redis_key, value=value, expire=None) + + @classmethod + async def _del_configs_from_redis(cls, redis: Redis, tenant_id: int) -> None: """删除租户配置的 Redis 缓存""" - redis_keys = [f"{RedisInitKeyConfig.TENANT_CONFIG.key}:{tenant_id}:{k}" for k in keys] - if redis_keys: - await RedisCURD(redis).delete(*redis_keys) + redis_key = f"{RedisInitKeyConfig.TENANT_CONFIG.key}:{tenant_id}" + await RedisCURD(redis).delete(redis_key) @classmethod async def update_config_service( - cls, auth: AuthSchema, redis: Redis, tenant_id: int, items: list[TenantConfigItem] - ) -> list[dict]: - """批量更新租户配置（同步 Redis 缓存）""" - from sqlalchemy import select + cls, auth: AuthSchema, redis: Redis, tenant_id: int, config: dict + ) -> list[TenantConfigOutSchema]: + """更新租户配置（同步 Redis 缓存）""" + tenant = await TenantCRUD(auth).get(id=tenant_id) + if not tenant: + raise CustomException(msg="租户不存在") + + config_fields = [ + "name", "description", "version", "logo_url", "favicon", "login_bg", + "copyright", "keep_record", "help_doc", "privacy", "clause", "git_code" + ] + + for field in config_fields: + if field in config: + setattr(tenant, field, config[field]) - for item in items: - stmt = ( - select(TenantConfigModel) - .where( - TenantConfigModel.tenant_id == tenant_id, - TenantConfigModel.config_key == item.config_key, - ) - .limit(1) - ) - result = await auth.db.execute(stmt) - cfg = result.scalar_one_or_none() - if cfg: - cfg.config_value = item.config_value - if item.config_type: - cfg.config_type = item.config_type - else: - cfg = TenantConfigModel( - tenant_id=tenant_id, - config_key=item.config_key, - config_value=item.config_value, - config_type=item.config_type or "string", - ) - auth.db.add(cfg) await auth.db.flush() # 刷新 DB 数据并同步到 Redis - configs = await cls.get_config_service(auth, tenant_id) - await cls._sync_configs_to_redis(redis, tenant_id, configs) - log.info(f"租户[{tenant_id}]配置已更新, keys={[i.config_key for i in items]}") - return configs + new_config = await cls.get_config_service(auth, tenant_id) + await cls._sync_configs_to_redis(redis, tenant_id, new_config) + logger.info(f"租户[{tenant_id}]配置已更新") + return [ + TenantConfigOutSchema(config_key=k, config_value=str(v) if v is not None else None) + for k, v in new_config.items() + ] # ============ P1: 租户菜单 ============ - - @classmethod - async def get_menus_service(cls, auth: AuthSchema, tenant_id: int) -> list[int]: - """获取租户菜单权限（返回 menu_id 列表）""" - from sqlalchemy import select - - stmt = select(TenantMenuModel.menu_id).where(TenantMenuModel.tenant_id == tenant_id) - result = await auth.db.execute(stmt) - return [row[0] for row in result.all()] - - @classmethod - async def set_menus_service( - cls, auth: AuthSchema, tenant_id: int, data: TenantMenuSetSchema - ) -> None: - """批量设置租户菜单权限（先清空再写入）""" - from sqlalchemy import delete - - await auth.db.execute(delete(TenantMenuModel).where(TenantMenuModel.tenant_id == tenant_id)) - for menu_id in data.menu_ids: - auth.db.add(TenantMenuModel(tenant_id=tenant_id, menu_id=menu_id)) - await auth.db.flush() - log.info(f"租户[{tenant_id}]菜单权限已设置, count={len(data.menu_ids)}") - - @staticmethod - async def get_tenant_menu_ids(auth: AuthSchema, tenant_id: int) -> list[int]: - """获取租户可用菜单ID列表（套餐菜单 + 自定义授权菜单的并集） - - 供角色/用户权限约束使用。 - """ - from app.api.v1.module_platform.package.service import PackageService - - return await PackageService.get_tenant_available_menu_ids(auth, tenant_id) + # 租户菜单权限现通过 Package → PackageMenuModel 统一控制 + # get_menus_service / set_menus_service / get_tenant_menu_ids 已移除 + # 改用 PackageService.get_package_menu_ids / get_tenant_available_menu_ids # ============ P1: 初始化缓存 ============ @@ -618,59 +601,399 @@ class TenantService: tenants = result.scalars().all() for tenant in tenants: - config_stmt = select(TenantConfigModel).where( - TenantConfigModel.tenant_id == tenant.id - ) - config_result = await session.execute(config_stmt) - configs = config_result.scalars().all() - config_list = [ - TenantConfigOutSchema.model_validate(c).model_dump() for c in configs + config_fields = [ + "name", "description", "version", "logo_url", "favicon", "login_bg", + "copyright", "keep_record", "help_doc", "privacy", "clause", "git_code" ] + config = {field: getattr(tenant, field, None) for field in config_fields} - if config_list: - await cls._sync_configs_to_redis(redis, tenant.id, config_list) - log.info( - f"✅ 租户[{tenant.name}](id={tenant.id}) {len(config_list)} 条配置已缓存到 Redis" - ) - else: - log.warning(f"⚠️ 租户[{tenant.name}](id={tenant.id}) 无配置数据，跳过缓存") + await cls._sync_configs_to_redis(redis, tenant.id, config) + logger.info(f"✅ 租户[{tenant.name}](id={tenant.id}) 配置已缓存到 Redis") - # ============ P1: 到期提醒 ============ + # ============ 续期 & 套餐变更预览 ============ + + @classmethod + async def renew_service(cls, auth: AuthSchema, tenant_id: int, end_time: str) -> TenantOutSchema: + """租户续期：延长 end_time 并恢复为 active 状态 + + 仅 active(0)/grace(1)/suspended(2) 状态可续期。 + expired(4)/frozen(3)/archived(5) 不可续期。 + + 参数: + - auth (AuthSchema): 认证信息 + - tenant_id (int): 租户ID + - end_time (str): 新的结束时间 + + 返回: + - dict: 更新后的租户信息 + """ + from datetime import datetime + + tenant = await TenantCRUD(auth).get(id=tenant_id) + if not tenant: + raise CustomException(msg="租户不存在") + + if tenant.status not in (0, 1, 2): + status_labels = {0: "正常", 1: "宽限期", 2: "暂停", 3: "冻结", 4: "过期", 5: "归档"} + current_label = status_labels.get(str(tenant.status), str(tenant.status)) + raise CustomException( + msg=f"当前租户状态为「{current_label}」，仅正常/宽限期/暂停状态可续期" + ) + + new_end = datetime.fromisoformat(end_time) if isinstance(end_time, str) else end_time + if new_end <= datetime.now(): + raise CustomException(msg="续期结束时间必须晚于当前时间") + + tenant.end_time = new_end + tenant.status = 0 + tenant.grace_start_time = None + + await auth.db.flush() + logger.info(f"租户[{tenant.name}]续期成功, 新的结束时间: {end_time}") + + return TenantOutSchema.model_validate(tenant) + + @classmethod + async def package_change_preview_service( + cls, auth: AuthSchema, tenant_id: int, new_package_id: int + ) -> PackageChangePreviewOut: + """套餐变更影响预览 + + 返回受影响角色、菜单清单、配额对比等，供超管确认后再执行变更。 + + 参数: + - auth (AuthSchema): 认证信息 + - tenant_id (int): 租户ID + - new_package_id (int): 目标套餐ID + + 返回: + - dict: 预览结果 + """ + from sqlalchemy import func, select + + from app.api.v1.module_platform.menu.model import MenuModel + from app.api.v1.module_platform.package.crud import PackageCRUD + from app.api.v1.module_platform.package.service import PackageService + from app.api.v1.module_system.role.model import RoleMenusModel, RoleModel + from app.api.v1.module_system.user.model import UserModel + + tenant = await TenantCRUD(auth).get(id=tenant_id) + if not tenant: + raise CustomException(msg="租户不存在") + + new_package = await PackageCRUD(auth).get(id=new_package_id) + if not new_package: + raise CustomException(msg="目标套餐不存在") + + # 当前可用菜单 + current_menu_ids = await PackageService.get_tenant_available_menu_ids(auth, tenant_id) + + # 新套餐可用菜单（直接取套餐菜单，不再包含自定义授权） + new_menu_ids = set( + await PackageService.get_package_menu_ids(auth, new_package_id) + ) + final_menu_ids = new_menu_ids # 不再合并租户自定义菜单 + + # 差异计算 + removed_ids = current_menu_ids - final_menu_ids + added_ids = final_menu_ids - current_menu_ids + + removed_menus = [] + added_menus = [] + if removed_ids: + menu_stmt = select(MenuModel).where(MenuModel.id.in_(removed_ids)) + menu_result = await auth.db.execute(menu_stmt) + removed_menus = [ + {"id": m.id, "name": m.name, "route_path": m.route_path} + for m in menu_result.scalars().all() + ] + if added_ids: + menu_stmt = select(MenuModel).where(MenuModel.id.in_(added_ids)) + menu_result = await auth.db.execute(menu_stmt) + added_menus = [ + {"id": m.id, "name": m.name, "route_path": m.route_path} + for m in menu_result.scalars().all() + ] + + # 受影响角色 + role_stmt = select(RoleModel).where(RoleModel.tenant_id == tenant_id) + role_result = await auth.db.execute(role_stmt) + roles = role_result.scalars().all() + + affected_roles = [] + total_affected_users = 0 + for role in roles: + # 查该角色下有多少菜单会被移除 + role_menu_stmt = select(RoleMenusModel.menu_id).where( + RoleMenusModel.role_id == role.id + ) + rm_result = await auth.db.execute(role_menu_stmt) + role_menu_ids = {row[0] for row in rm_result.all()} + affected_menu_count = len(role_menu_ids & removed_ids) + + # 查该角色下用户数 + user_count_stmt = ( + select(func.count()) + .select_from(UserModel) + .join(UserModel.roles) + .where(RoleModel.id == role.id) + ) + uc_result = await auth.db.execute(user_count_stmt) + user_count = uc_result.scalar() or 0 + + affected_roles.append({ + "id": role.id, + "name": role.name, + "code": role.code, + "affected_menu_count": affected_menu_count, + "user_count": user_count, + }) + total_affected_users += user_count + + # 配额对比（从套餐读取） + old_pkg = None + if tenant.package_id: + old_pkg = await PackageCRUD(auth).get(id=tenant.package_id) + quota_changes = { + "max_users": { + "current": old_pkg.max_users if old_pkg else 0, + "new": new_package.max_users, + }, + "max_roles": { + "current": old_pkg.max_roles if old_pkg else 0, + "new": new_package.max_roles, + }, + "max_depts": { + "current": old_pkg.max_depts if old_pkg else 0, + "new": new_package.max_depts, + }, + } + + return PackageChangePreviewOut( + new_package_id=new_package.id, + new_package_name=new_package.name, + affected_roles=affected_roles, + removed_menus=removed_menus, + added_menus=added_menus, + quota_changes=quota_changes, + total_affected_users=total_affected_users, + ) + + # ============ P1: 到期提醒（多阶段自动处理） ============ @staticmethod async def check_tenant_expiry() -> None: - """定时任务：检查租户到期并发送通知 / 自动禁用""" - from datetime import datetime, timedelta + """定时任务：多阶段租户到期自动处理 - from app.core.db_session import async_session_factory + PRD §9 到期阶段： + grace(1) → 到期后第 1-7 天，仅提醒 + suspended(2) → 到期后第 8-14 天，禁用登录 + frozen(3) → 到期后第 15-30 天，只读模式 + expired(4) → 第 31 天起，归档候选 + """ + from datetime import datetime - async with async_session_factory() as db: - now = datetime.now() - # 扫描所有启用的租户 - stmt = sa.select(TenantModel).where( - TenantModel.status == "0", - TenantModel.end_time.isnot(None), + from sqlalchemy import text + + from app.core.database import async_db_session + + now = datetime.now() + + async with async_db_session() as session: + # 获取所有已过期的活跃租户（status=0） + rows = await session.execute( + text( + "SELECT id, name, contact_email, contact_name, " + "end_time, status FROM platform_tenant " + "WHERE status = '0' AND end_time IS NOT NULL AND end_time < :now" + ), + {"now": now}, ) - result = await db.execute(stmt) - tenants = result.scalars().all() + expired_tenants = rows.fetchall() - for t in tenants: - if t.end_time <= now: - # 已到期：自动禁用 - await db.execute( - sa.update(TenantModel).where(TenantModel.id == t.id).values(status="1") + for t in expired_tenants: + tenant_id, tenant_name, email, contact_name, end_time, cur_status = t + days_past = (now - end_time).days if end_time else 0 + + if days_past <= 7: + new_status, label = 1, "宽限期" + elif days_past <= 14: + new_status, label = 2, "已停用" + elif days_past <= 30: + new_status, label = 3, "已冻结" + else: + new_status, label = 4, "已过期" + + if new_status == cur_status: + continue + + await session.execute( + text("UPDATE platform_tenant SET status = :s WHERE id = :tid"), + {"s": new_status, "tid": tenant_id}, + ) + logger.info( + f"租户状态切换: id={tenant_id} name={tenant_name} " + f"status={cur_status}→{new_status} ({label})" + ) + + # 发送通知邮件 + if email: + await TenantService._send_expiry_email( + tenant_name, contact_name, email, end_time, days_past, label ) - log.info(f"租户[{t.name}]已到期，自动禁用") - elif t.end_time <= now + timedelta(days=1): - TenantService._notify_expiry(t, 1) - elif t.end_time <= now + timedelta(days=7): - TenantService._notify_expiry(t, 7) - elif t.end_time <= now + timedelta(days=30): - TenantService._notify_expiry(t, 30) - await db.commit() + await session.commit() + + logger.info(f"到期检查完成，处理了 {len(expired_tenants)} 个过期租户") @staticmethod - async def _notify_expiry(tenant: TenantModel, days: int) -> None: - """发送到期提醒通知""" - log.info(f"租户[{tenant.name}]将在 {days} 天后到期，联系人: {tenant.contact_email}") + async def send_grace_reminders() -> None: + """定时任务：向宽限期租户发送续费提醒邮件（每天 09:00）""" + from datetime import datetime + + from sqlalchemy import text + + from app.core.database import async_db_session + + async with async_db_session() as session: + rows = await session.execute( + text( + "SELECT id, name, contact_email, contact_name, end_time " + "FROM platform_tenant " + "WHERE status = '1' AND contact_email IS NOT NULL AND contact_email != ''" + ) + ) + grace_tenants = rows.fetchall() + + sent = 0 + for t in grace_tenants: + tenant_id, name, email, contact_name, end_time = t + days_past = (datetime.now() - end_time).days if end_time else 0 + + try: + ok = await TenantService._send_renew_email( + name, contact_name, email, days_past + ) + if ok: + sent += 1 + except Exception as e: + logger.warning(f"续费提醒邮件发送失败: tenant_id={tenant_id}, err={e}") + + logger.info(f"续费提醒完成，共发送 {sent}/{len(grace_tenants)} 封邮件") + + @staticmethod + async def clean_expired_tenants() -> None: + """定时任务：将过期超 90 天租户归档，清理旧审计日志（每月 1 号 02:00）""" + from datetime import datetime, timedelta + + from sqlalchemy import text + + from app.core.database import async_db_session + + cutoff = datetime.now() - timedelta(days=90) + + async with async_db_session() as session: + # 归档过期租户 + result = await session.execute( + text( + "SELECT COUNT(*) FROM platform_tenant " + "WHERE status = '4' AND end_time < :cutoff" + ), + {"cutoff": cutoff}, + ) + count = result.scalar() or 0 + if count > 0: + await session.execute( + text( + "UPDATE platform_tenant SET status = '5' " + "WHERE status = '4' AND end_time < :cutoff" + ), + {"cutoff": cutoff}, + ) + await session.commit() + logger.info(f"已将 {count} 个过期超过 90 天的租户标记为归档") + + await session.commit() + + @staticmethod + async def _send_expiry_email( + tenant_name: str, + contact_name: str | None, + email: str, + end_time: object, + days_past: int, + label: str, + ) -> None: + """发送租户状态变更通知邮件""" + from app.config.setting import settings + from app.utils.email_util import render_template, send_email + + if not settings.SMTP_HOST: + return + + smtp_config = { + "host": settings.SMTP_HOST, + "port": settings.SMTP_PORT, + "username": settings.SMTP_USER, + "password": settings.SMTP_PASSWORD, + "from_addr": settings.SMTP_FROM, + "starttls": settings.SMTP_TLS, + "ssl_tls": settings.SMTP_SSL, + } + end_str = end_time.strftime("%Y-%m-%d") if hasattr(end_time, "strftime") else str(end_time) + + try: + html_body = await render_template( + "email/tenant_expiry_notice.html", + tenant_name=tenant_name, + contact_name=contact_name or "管理员", + days_expired=days_past, + status_name=label, + end_time=end_str, + site_url=getattr(settings, "SITE_URL", ""), + ) + await send_email( + smtp_config=smtp_config, + recipients=[email], + subject=f"【重要】租户 {tenant_name} 服务状态变更通知", + body=html_body, + html=True, + ) + except Exception as e: + logger.warning(f"到期通知邮件发送失败: tenant={tenant_name}, err={e}") + + @staticmethod + async def _send_renew_email( + name: str, contact_name: str | None, email: str, days_past: int + ) -> bool: + """发送续费提醒邮件""" + from app.config.setting import settings + from app.utils.email_util import render_template, send_email + + if not settings.SMTP_HOST: + return False + + smtp_config = { + "host": settings.SMTP_HOST, + "port": settings.SMTP_PORT, + "username": settings.SMTP_USER, + "password": settings.SMTP_PASSWORD, + "from_addr": settings.SMTP_FROM, + "starttls": settings.SMTP_TLS, + "ssl_tls": settings.SMTP_SSL, + } + + html_body = await render_template( + "email/tenant_renew_reminder.html", + tenant_name=name, + contact_name=contact_name or "管理员", + days_expired=days_past, + renew_url=f"{getattr(settings, 'SITE_URL', '')}/tenant/order/create", + ) + return await send_email( + smtp_config=smtp_config, + recipients=[email], + subject=f"【续费提醒】租户 {name} 服务即将到期", + body=html_body, + html=True, + ) diff --git a/backend/app/api/v1/module_platform/ticket/crud.py b/backend/app/api/v1/module_platform/ticket/crud.py deleted file mode 100644 index e6dcdeaf..00000000 --- a/backend/app/api/v1/module_platform/ticket/crud.py +++ /dev/null @@ -1,51 +0,0 @@ -from typing import Any - -from app.api.v1.module_system.auth.schema import AuthSchema -from app.core.base_crud import CRUDBase - -from .model import TicketModel -from .schema import TicketCreateSchema, TicketUpdateSchema - - -class TicketCRUD(CRUDBase[TicketModel, TicketCreateSchema, TicketUpdateSchema]): - """工单 CRUD""" - - def __init__(self, auth: AuthSchema) -> None: - self.auth = auth - super().__init__(model=TicketModel, auth=auth) - - async def page_crud( - self, - offset: int, - limit: int, - order_by: list[dict[str, str]] | None, - search: dict | None = None, - out_schema: type | None = None, - preload: list[str | Any] | None = None, - ) -> dict: - from .schema import TicketOutSchema - - return await self.page( - offset=offset, - limit=limit, - order_by=order_by or [{"id": "asc"}], - search=search or {}, - out_schema=out_schema or TicketOutSchema, - preload=preload, - ) - - async def get_by_id_crud(self, id: int) -> TicketModel | None: - return await self.get(id=id) - - async def create_crud(self, data: TicketCreateSchema) -> TicketModel | None: - return await self.create(data=data) - - async def update_crud(self, id: int, data: TicketUpdateSchema) -> TicketModel | None: - return await self.update(id=id, data=data) - - async def delete_crud(self, ids: list[int]) -> None: - await self.delete(ids=ids) - - async def set_crud(self, ids: list[int], **kwargs) -> None: - """批量设置工单状态""" - await self.set(ids=ids, **kwargs) diff --git a/backend/app/api/v1/module_system/__init__.py b/backend/app/api/v1/module_system/__init__.py index ce34f8e7..87f7fb23 100644 --- a/backend/app/api/v1/module_system/__init__.py +++ b/backend/app/api/v1/module_system/__init__.py @@ -6,58 +6,35 @@ - 用户管理 (user) - 角色管理 (role) - 部门管理 (dept) -- 菜单管理 (menu) - 岗位管理 (position) - 字典管理 (dict) - 公告管理 (notice) - 参数管理 (params) -- 操作日志 (operationlog) +- 日志管理 (log) +- 工单管理 (ticket) """ from fastapi import APIRouter -system_router = APIRouter(prefix="/system", tags=["系统管理"]) -_routers_included = False +from app.api.v1.module_system.auth.controller import AuthRouter +from app.api.v1.module_system.dept.controller import DeptRouter +from app.api.v1.module_system.dict.controller import DictRouter +from app.api.v1.module_system.log import LogRouter +from app.api.v1.module_system.notice.controller import NoticeRouter +from app.api.v1.module_system.params.controller import ParamsRouter +from app.api.v1.module_system.position.controller import PositionRouter +from app.api.v1.module_system.role.controller import RoleRouter +from app.api.v1.module_system.ticket.controller import TicketRouter +from app.api.v1.module_system.user.controller import UserRouter +system_router = APIRouter(prefix="/system") -def _include_routers(): - """延迟导入路由以避免循环导入""" - global _routers_included - if _routers_included: - return - - from app.api.v1.module_system.auth.controller import AuthRouter - from app.api.v1.module_system.dept.controller import DeptRouter - from app.api.v1.module_system.dict.controller import DictRouter - from app.api.v1.module_system.menu.controller import MenuRouter - from app.api.v1.module_system.notice.controller import NoticeRouter - from app.api.v1.module_system.operationlog.controller import OperationLogRouter - from app.api.v1.module_system.params.controller import ParamsRouter - from app.api.v1.module_system.position.controller import PositionRouter - from app.api.v1.module_system.role.controller import RoleRouter - from app.api.v1.module_system.user.controller import UserRouter - - system_router.include_router(AuthRouter) - system_router.include_router(DeptRouter) - system_router.include_router(DictRouter) - system_router.include_router(OperationLogRouter) - system_router.include_router(MenuRouter) - system_router.include_router(NoticeRouter) - system_router.include_router(ParamsRouter) - system_router.include_router(PositionRouter) - system_router.include_router(RoleRouter) - system_router.include_router(UserRouter) - _routers_included = True - - -# 提供一个属性访问器，在首次访问时才加载路由 -class _SystemRouter(APIRouter): - def __getattr__(self, name): - _include_routers() - return getattr(system_router, name) - - -# 使用包装类延迟路由加载 -system_router = _SystemRouter(prefix="/system", tags=["系统管理"]) - -# 保持向后兼容性，直接暴露 include_router 方法 -system_router.include_router = lambda router: _include_routers() or system_router.include_router(router) +system_router.include_router(AuthRouter) +system_router.include_router(DeptRouter) +system_router.include_router(DictRouter) +system_router.include_router(LogRouter) +system_router.include_router(NoticeRouter) +system_router.include_router(ParamsRouter) +system_router.include_router(PositionRouter) +system_router.include_router(RoleRouter) +system_router.include_router(TicketRouter) +system_router.include_router(UserRouter) diff --git a/backend/app/api/v1/module_system/auth/controller.py b/backend/app/api/v1/module_system/auth/controller.py index 98a7dde7..c94ec35d 100644 --- a/backend/app/api/v1/module_system/auth/controller.py +++ b/backend/app/api/v1/module_system/auth/controller.py @@ -4,14 +4,22 @@ from typing import Annotated from fastapi import APIRouter, Depends, Path, Query, Request from fastapi.responses import JSONResponse, RedirectResponse +from fastapi_cache import FastAPICache +from fastapi_cache.decorator import cache from redis.asyncio.client import Redis from sqlalchemy.ext.asyncio import AsyncSession -from app.common.response import ErrorResponse, SuccessResponse +from app.common.response import ErrorResponse, ResponseSchema, SuccessResponse from app.config.setting import settings +from app.core.base_schema import ( + AuthSchema, + JWTOutSchema, + LogoutPayloadSchema, + RefreshTokenPayloadSchema, +) from app.core.dependencies import db_getter, get_current_user, redis_getter from app.core.exceptions import CustomException -from app.core.logger import log +from app.core.logger import logger from app.core.redis_crud import RedisCURD from app.core.router_class import OperationLogRoute from app.core.security import CustomOAuth2PasswordRequestForm @@ -26,27 +34,34 @@ from .oauth_service import ( save_oauth_state, ) from .schema import ( - AuthSchema, AutoLoginTokenSchema, AutoLoginUserSchema, CaptchaOutSchema, - JWTOutSchema, + ForgotPasswordSchema, LoginWithTenantsSchema, - LogoutPayloadSchema, - RefreshTokenPayloadSchema, + ResetPasswordWithTokenSchema, SelectTenantOutSchema, SelectTenantSchema, TenantOptionSchema, + TenantRegisterOutSchema, + TenantRegisterSchema, +) +from .service import ( + AutoLoginService, + CaptchaService, + LoginService, + PasswordResetService, + TenantRegisterService, ) -from .service import AutoLoginService, CaptchaService, LoginService -AuthRouter = APIRouter(route_class=OperationLogRoute, prefix="/auth", tags=["认证授权"]) +AuthRouter = APIRouter(route_class=OperationLogRoute, prefix="/auth", tags=["系统管理/认证授权"]) + +_AUTH_TENANTS_NS = "auth_tenants" @AuthRouter.post( "/login", summary="登录", - description="登录（返回可选租户列表）", response_model=LoginWithTenantsSchema, ) async def login_for_access_token_controller( @@ -74,23 +89,20 @@ async def login_for_access_token_controller( request=request, redis=redis, login_form=login_form, db=db ) - log.info(f"用户{login_form.username}登录成功") + logger.info(f"用户{login_form.username}登录成功") # 如果是文档请求，则不记录日志 if settings.DOCS_URL in request.headers.get("referer", ""): - return login_result.model_dump() - return SuccessResponse(data=login_result.model_dump(), msg="登录成功") + return login_result + return SuccessResponse(data=login_result, msg="登录成功") @AuthRouter.post( "/token/refresh", summary="刷新token", - description="刷新token", - response_model=JWTOutSchema, - dependencies=[Depends(get_current_user)], + response_model=ResponseSchema[JWTOutSchema], ) async def get_new_token_controller( - request: Request, payload: RefreshTokenPayloadSchema, db: Annotated[AsyncSession, Depends(db_getter)], redis: Annotated[Redis, Depends(redis_getter)], @@ -99,7 +111,6 @@ async def get_new_token_controller( 刷新token 参数: - - request (Request): FastAPI请求对象 - payload (RefreshTokenPayloadSchema): 刷新令牌负载模型 - db (AsyncSession): 数据库会话对象 - redis (Redis): Redis 客户端对象 @@ -110,20 +121,16 @@ async def get_new_token_controller( 异常: - CustomException: 刷新令牌失败时抛出异常。 """ - # 解析当前的访问Token以获取用户名 new_token = await LoginService.refresh_token_service( - db=db, request=request, redis=redis, refresh_token=payload + db=db, redis=redis, refresh_token=payload ) - token_dict = new_token.model_dump() - log.info(f"刷新token成功: {token_dict}") - return SuccessResponse(data=token_dict, msg="刷新成功") + return SuccessResponse(data=new_token, msg="刷新成功") @AuthRouter.get( "/captcha/get", summary="获取验证码", - description="获取登录验证码", - response_model=CaptchaOutSchema, + response_model=ResponseSchema[CaptchaOutSchema], ) async def get_captcha_for_login_controller( redis: Annotated[Redis, Depends(redis_getter)], @@ -142,15 +149,14 @@ async def get_captcha_for_login_controller( """ # 获取验证码 captcha = await CaptchaService.get_captcha_service(redis=redis) - log.info("获取验证码成功") return SuccessResponse(data=captcha, msg="获取验证码成功") @AuthRouter.post( "/logout", summary="退出登录", - description="退出登录", dependencies=[Depends(get_current_user)], + response_model=ResponseSchema[None], ) async def logout_controller( payload: LogoutPayloadSchema, @@ -170,7 +176,7 @@ async def logout_controller( - CustomException: 退出登录失败时抛出异常。 """ if await LoginService.logout_service(redis=redis, token=payload): - log.info("退出成功") + logger.info("退出成功") return SuccessResponse(msg="退出成功") return ErrorResponse(msg="退出失败") @@ -178,8 +184,7 @@ async def logout_controller( @AuthRouter.get( "/auto-login/users", summary="获取免登录用户列表", - description="获取可用于免登录快速登录的用户列表", - response_model=list[AutoLoginUserSchema], + response_model=ResponseSchema[list[AutoLoginUserSchema]], ) async def get_auto_login_users_controller( auth: Annotated[AuthSchema, Depends(get_current_user)], @@ -203,8 +208,7 @@ async def get_auto_login_users_controller( @AuthRouter.post( "/auto-login/token", summary="获取免登录Token", - description="根据用户ID生成免登录Token", - response_model=AutoLoginTokenSchema, + response_model=ResponseSchema[AutoLoginTokenSchema], ) async def get_auto_login_token_controller( auth: Annotated[AuthSchema, Depends(get_current_user)], @@ -234,8 +238,7 @@ async def get_auto_login_token_controller( @AuthRouter.post( "/auto-login", summary="免登录", - description="使用免登录Token快速登录", - response_model=JWTOutSchema, + response_model=ResponseSchema[JWTOutSchema], ) async def auto_login_controller( request: Request, @@ -258,15 +261,14 @@ async def auto_login_controller( login_token = await AutoLoginService.auto_login_service( request=request, redis=redis, db=db, token=token ) - log.info("用户免登录成功") - return SuccessResponse(data=login_token.model_dump(), msg="登录成功") + logger.info("用户免登录成功") + return SuccessResponse(data=login_token, msg="登录成功") @AuthRouter.post( "/select-tenant", summary="选择租户", - description="登录后选择当前操作的租户，签发含租户上下文的新 JWT Token", - response_model=SelectTenantOutSchema, + response_model=ResponseSchema[SelectTenantOutSchema], dependencies=[Depends(get_current_user)], ) async def select_tenant_controller( @@ -292,16 +294,17 @@ async def select_tenant_controller( result = await LoginService.select_tenant_service( request=request, redis=redis, auth=auth, tenant_id=data.tenant_id ) - return SuccessResponse(data=result.model_dump(), msg="租户切换成功") + await FastAPICache.clear(namespace=_AUTH_TENANTS_NS) + return SuccessResponse(data=result, msg="租户切换成功") @AuthRouter.get( "/tenants", summary="获取可选租户列表", - description="返回当前用户关联的所有可选租户", - response_model=list[TenantOptionSchema], + response_model=ResponseSchema[list[TenantOptionSchema]], dependencies=[Depends(get_current_user)], ) +@cache(expire=120, namespace=_AUTH_TENANTS_NS) async def get_user_tenants_controller( auth: Annotated[AuthSchema, Depends(get_current_user)], db: Annotated[AsyncSession, Depends(db_getter)], @@ -323,7 +326,6 @@ async def get_user_tenants_controller( @AuthRouter.get( "/oauth/{provider}/login", summary="第三方OAuth跳转", - description="浏览器重定向到微信/GitHub/Gitee/QQ 授权页；redirect_uri 为授权完成后回到前端的登录页地址（如 http://localhost:5173/login）。", ) async def oauth_login_redirect_controller( request: Request, @@ -413,3 +415,84 @@ async def oauth_callback_controller( except CustomException as e: fe = await resolve_frontend() return RedirectResponse(url=oauth_service_error_redirect(fe, e.msg), status_code=302) + + +@AuthRouter.post( + "/tenant/register", + summary="租户自助注册", + response_model=ResponseSchema[TenantRegisterOutSchema], +) +async def tenant_register_controller( + data: TenantRegisterSchema, + db: Annotated[AsyncSession, Depends(db_getter)], +) -> JSONResponse: + """ + 租户自助注册（PRD §4.5） + + 参数: + - data (TenantRegisterSchema): 注册信息 + + 返回: + - TenantRegisterOutSchema: 注册结果，含 tenant_id/user_id/试用到期日 + """ + result = await TenantRegisterService.register( + db=db, + username=data.username, + password=data.password, + email=data.email, + tenant_name=data.tenant_name, + ) + logger.info(f"新租户注册: username={data.username} tenant={result.tenant_name}") + return SuccessResponse(data=result, msg=result.message) + + +# ─── 忘记密码（自助重置）──────────────────────────────────── + +@AuthRouter.post( + "/forgot-password", + summary="忘记密码", + response_model=ResponseSchema[str], +) +async def forgot_password_controller( + data: ForgotPasswordSchema, + redis: Annotated[Redis, Depends(redis_getter)], + db: Annotated[AsyncSession, Depends(db_getter)], +) -> JSONResponse: + """ + 忘记密码：提交邮箱，接收重置邮件 + + 参数: + - data (ForgotPasswordSchema): 邮箱 + + 返回: + - str: 提示信息（无论成功与否均返回相同文案） + """ + msg = await PasswordResetService.forgot_password_service( + redis=redis, db=db, email=data.email + ) + return SuccessResponse(data=msg, msg="邮件已发送") + + +@AuthRouter.post( + "/reset-password", + summary="重置密码", + response_model=ResponseSchema[str], +) +async def reset_password_controller( + data: ResetPasswordWithTokenSchema, + redis: Annotated[Redis, Depends(redis_getter)], + db: Annotated[AsyncSession, Depends(db_getter)], +) -> JSONResponse: + """ + 重置密码：使用令牌 + 新密码 + + 参数: + - data (ResetPasswordWithTokenSchema): 令牌 + 新密码 + + 返回: + - str: 重置结果 + """ + msg = await PasswordResetService.reset_password_with_token_service( + redis=redis, db=db, token=data.token, new_password=data.new_password + ) + return SuccessResponse(data=msg, msg="密码已重置") diff --git a/backend/app/api/v1/module_system/auth/oauth_service.py b/backend/app/api/v1/module_system/auth/oauth_service.py index 1c3e9aee..b8fa4170 100644 --- a/backend/app/api/v1/module_system/auth/oauth_service.py +++ b/backend/app/api/v1/module_system/auth/oauth_service.py @@ -20,17 +20,16 @@ from fastapi import Request from redis.asyncio.client import Redis from sqlalchemy.ext.asyncio import AsyncSession -from app.api.v1.module_system.auth.schema import AuthSchema from app.api.v1.module_system.user.crud import UserCRUD from app.api.v1.module_system.user.model import UserModel from app.api.v1.module_system.user.schema import UserRegisterSchema from app.api.v1.module_system.user.service import UserService from app.config.setting import settings +from app.core.base_schema import AuthSchema, JWTOutSchema from app.core.exceptions import CustomException -from app.core.logger import log +from app.core.logger import logger from app.core.redis_crud import RedisCURD -from .schema import JWTOutSchema from .service import LoginService OAuthProvider = Literal["wechat", "qq", "github", "gitee"] @@ -138,7 +137,7 @@ async def _http_json(method: str, url: str, **kwargs: Any) -> Any: return r.json() except json.JSONDecodeError: text = r.text - log.error(f"OAuth 非 JSON 响应: {text[:500]}") + logger.error(f"OAuth 非 JSON 响应: {text[:500]}") raise CustomException(msg="OAuth 接口返回异常") @@ -313,7 +312,7 @@ async def ensure_oauth_user( ) -> UserModel: auth = AuthSchema(db=db, user=None, tenant_id=1, check_data_scope=False) username = _username_for_oauth(provider, unique_id) - existing = await UserCRUD(auth).get_by_username_crud(username=username) + existing = await UserCRUD(auth).get(username=username) if existing: return existing @@ -323,11 +322,18 @@ async def ensure_oauth_user( name=(display_name or username)[:32], role_ids=list(settings.OAUTH_DEFAULT_ROLE_IDS), ) - await UserService.register_user_service(auth=auth, data=reg) - user = await UserCRUD(auth).get_by_username_crud(username=username) + try: + await UserService.register_user_service(auth=auth, data=reg) + except Exception: + # 并发创建可能触发唯一约束冲突，回退到再次查询 + existing = await UserCRUD(auth).get(username=username) + if existing: + return existing + raise CustomException(msg="OAuth 注册失败") + user = await UserCRUD(auth).get(username=username) if not user: raise CustomException(msg="OAuth 注册失败") - log.info(f"OAuth 自动注册用户: {username} ({provider})") + logger.info(f"OAuth 自动注册用户: {username} ({provider})") return user @@ -375,11 +381,11 @@ async def complete_oauth_login( raise CustomException(msg="不支持的 OAuth 渠道") user = await ensure_oauth_user(db=db, provider=provider, unique_id=uid, display_name=name) - if user.status == "1": + if user.status == 1: raise CustomException(msg="用户已被停用") user = await UserCRUD( - AuthSchema(db=db, user=None, check_data_scope=False) + AuthSchema(db=db, user=None, tenant_id=1, check_data_scope=False) ).update_last_login_crud(id=user.id) if not user: raise CustomException(msg="用户不存在") diff --git a/backend/app/api/v1/module_system/auth/schema.py b/backend/app/api/v1/module_system/auth/schema.py index 80cb6868..e9e9945e 100644 --- a/backend/app/api/v1/module_system/auth/schema.py +++ b/backend/app/api/v1/module_system/auth/schema.py @@ -1,15 +1,7 @@ -from datetime import datetime -from pydantic import BaseModel, ConfigDict, Field, model_validator +from pydantic import BaseModel, ConfigDict, Field -# 从 core 模块导入基础认证 schema，避免循环导入 -from app.core.auth_schema import ( - AuthSchema, - JWTPayloadSchema, - JWTOutSchema, - RefreshTokenPayloadSchema, - LogoutPayloadSchema, -) +from app.core.base_schema import JWTOutSchema class CaptchaOutSchema(BaseModel): @@ -73,3 +65,44 @@ class LoginWithTenantsSchema(JWTOutSchema): tenants: list[TenantOptionSchema] = Field(default_factory=list, description="可选租户列表") user_info: dict = Field(default_factory=dict, description="用户信息") + + +# ─── 租户自助注册 ────────────────────────────────────────────────────────────── + +class TenantRegisterSchema(BaseModel): + """租户自助注册请求""" + + username: str = Field(..., min_length=3, max_length=32, description="登录账号") + password: str = Field(..., min_length=6, max_length=128, description="登录密码") + email: str = Field(..., max_length=128, description="邮箱（用于接收通知）") + tenant_name: str | None = Field( + default=None, max_length=100, description="企业/团队名称（可选，默认：{用户名}的租户）" + ) + + +class TenantRegisterOutSchema(BaseModel): + """租户自助注册响应""" + + user_id: int = Field(..., description="用户ID") + username: str = Field(..., description="账号") + tenant_id: int = Field(..., description="租户ID") + tenant_name: str = Field(..., description="租户名称") + tenant_code: str = Field(..., description="租户编码") + package: str | None = Field(default=None, description="开通套餐") + trial_end: str = Field(..., description="试用到期日") + message: str = Field(default="注册成功", description="提示信息") + + +# ─── 忘记密码（自助重置）───────────────────────────────────────── + +class ForgotPasswordSchema(BaseModel): + """忘记密码：提交邮箱，接收重置邮件""" + + email: str = Field(..., max_length=128, description="注册时使用的邮箱") + + +class ResetPasswordWithTokenSchema(BaseModel): + """通过邮件链接重置密码""" + + token: str = Field(..., min_length=1, description="密码重置令牌") + new_password: str = Field(..., min_length=6, max_length=128, description="新密码") diff --git a/backend/app/api/v1/module_system/auth/service.py b/backend/app/api/v1/module_system/auth/service.py index 8575bf98..3f2be711 100644 --- a/backend/app/api/v1/module_system/auth/service.py +++ b/backend/app/api/v1/module_system/auth/service.py @@ -1,5 +1,5 @@ import json -import time +import secrets import uuid from datetime import datetime, timedelta from typing import NewType @@ -14,8 +14,15 @@ from app.api.v1.module_system.user.crud import UserCRUD from app.api.v1.module_system.user.model import UserModel from app.common.enums import RedisInitKeyConfig from app.config.setting import settings +from app.core.base_schema import ( + AuthSchema, + JWTOutSchema, + JWTPayloadSchema, + LogoutPayloadSchema, + RefreshTokenPayloadSchema, +) from app.core.exceptions import CustomException -from app.core.logger import log +from app.core.logger import logger from app.core.redis_crud import RedisCURD from app.core.security import ( CustomOAuth2PasswordRequestForm, @@ -28,23 +35,58 @@ from app.utils.hash_bcrpy_util import PwdUtil from app.utils.ip_local_util import IpLocalUtil from .schema import ( - AuthSchema, AutoLoginTokenSchema, AutoLoginUserSchema, CaptchaOutSchema, - JWTOutSchema, - JWTPayloadSchema, LoginWithTenantsSchema, - LogoutPayloadSchema, - RefreshTokenPayloadSchema, SelectTenantOutSchema, TenantOptionSchema, + TenantRegisterOutSchema, ) CaptchaKey = NewType("CaptchaKey", str) CaptchaBase64 = NewType("CaptchaBase64", str) +async def _write_login_log( + username: str, + status: int, + login_ip: str | None = None, + login_location: str | None = None, + request_os: str | None = None, + request_browser: str | None = None, + msg: str | None = None, +) -> None: + """写入登录日志（独立 session，避免事务回滚时丢失失败记录）""" + from app.api.v1.module_system.log.model import LoginLogModel + from app.core.database import async_db_session + + try: + async with async_db_session() as session: + async with session.begin(): + session.add( + LoginLogModel( + username=username, + status=status, + login_ip=login_ip, + login_location=login_location, + request_os=request_os, + request_browser=request_browser, + msg=msg, + ) + ) + except Exception: + pass # 登录日志写入失败不影响登录主流程 + + +def _resolve_request_ip(request: Request) -> str: + """从请求中解析客户端真实 IP""" + x_forwarded_for = request.headers.get("X-Forwarded-For") + if x_forwarded_for: + return x_forwarded_for.split(",")[0].strip() + return request.client.host if request.client else "127.0.0.1" + + class LoginService: """登录认证服务""" @@ -70,7 +112,13 @@ class LoginService: 异常: - CustomException: 认证失败时抛出异常。 """ - _t = time.time() + # 解析请求信息（IP、UA），供登录日志使用 + user_agent = parse(request.headers.get("user-agent")) + request_ip = _resolve_request_ip(request) + login_location = await IpLocalUtil.resolve_location_for_log(request_ip) + _login_os = user_agent.os.family + _login_browser = user_agent.browser.family + _login_username = login_form.username # 判断是否来自API文档 referer = request.headers.get("referer", "") @@ -85,26 +133,45 @@ class LoginService: key=login_form.captcha_key, captcha=login_form.captcha, ) - log.info(f"[登录计时] 验证码校验: {round((time.time() - _t) * 1000, 1)}ms") - _t2 = time.time() - # 用户认证 auth = AuthSchema(db=db) - user = await UserCRUD(auth).get_by_username_crud(username=login_form.username) - log.info(f"[登录计时] 数据库查询用户: {round((time.time() - _t2) * 1000, 1)}ms") - _t3 = time.time() + user = await UserCRUD(auth).get(username=login_form.username) if not user: + await _write_login_log( + username=_login_username, + status=2, + login_ip=request_ip, + login_location=login_location, + request_os=_login_os, + request_browser=_login_browser, + msg="用户不存在", + ) raise CustomException(msg="用户不存在") if not PwdUtil.verify_password( plain_password=login_form.password, password_hash=user.password ): + await _write_login_log( + username=_login_username, + status=2, + login_ip=request_ip, + login_location=login_location, + request_os=_login_os, + request_browser=_login_browser, + msg="账号或密码错误", + ) raise CustomException(msg="账号或密码错误") - log.info(f"[登录计时] Bcrypt密码校验: {round((time.time() - _t3) * 1000, 1)}ms") - _t4 = time.time() - - if user.status == "1": + if user.status == 1: + await _write_login_log( + username=_login_username, + status=2, + login_ip=request_ip, + login_location=login_location, + request_os=_login_os, + request_browser=_login_browser, + msg="用户已被停用", + ) raise CustomException(msg="用户已被停用") # 检查用户的默认租户是否正常 @@ -113,17 +180,24 @@ class LoginService: from app.api.v1.module_platform.tenant.model import TenantModel tenant_stmt = ( select(TenantModel) - .where(TenantModel.id == user.tenant_id, TenantModel.status == "0", TenantModel.is_deleted.is_(False)) + .where(TenantModel.id == user.tenant_id, TenantModel.status == 0, TenantModel.is_deleted.is_(False)) .limit(1) ) tenant_result = await auth.db.execute(tenant_stmt) if not tenant_result.scalar_one_or_none(): + await _write_login_log( + username=_login_username, + status=2, + login_ip=request_ip, + login_location=login_location, + request_os=_login_os, + request_browser=_login_browser, + msg="所属租户已被禁用", + ) raise CustomException(msg="所属租户已被禁用，请联系平台管理员") # 更新最后登录时间 - user = await UserCRUD(auth).update_last_login_crud(id=user.id) - log.info(f"[登录计时] 更新登录时间: {round((time.time() - _t4) * 1000, 1)}ms") - _t5 = time.time() + await UserCRUD(auth).update_last_login(id=user.id) if not user: raise CustomException(msg="用户不存在") @@ -137,20 +211,13 @@ class LoginService: user=user, login_type=login_form.login_type, ) - log.info( - f"[登录计时] 创建Token(含IP解析+Redis写入+在线记录): {round((time.time() - _t5) * 1000, 1)}ms" - ) - - log.info(f"[登录计时] ⭐ 登录总耗时: {round((time.time() - _t) * 1000, 1)}ms") # 查询用户关联的租户列表 - _tt = time.time() tenants = await cls.get_user_tenants_service( - auth=AuthSchema(db=db, tenant_id=user.tenant_id, check_data_scope=False), + auth=AuthSchema(db=db, user=user, tenant_id=user.tenant_id, check_data_scope=False), db=db, user_id=user.id, ) - log.info(f"[登录计时] 查询租户列表: {round((time.time() - _tt) * 1000, 1)}ms") user_info = { "id": user.id, @@ -160,6 +227,17 @@ class LoginService: "is_super_admin": user.is_superuser, } + # 写入登录成功日志 + await _write_login_log( + username=user.username, + status=1, + login_ip=request_ip, + login_location=login_location, + request_os=_login_os, + request_browser=_login_browser, + msg="登录成功", + ) + return LoginWithTenantsSchema( access_token=token.access_token, refresh_token=token.refresh_token, @@ -193,14 +271,7 @@ class LoginService: request.scope["session_id"] = session_id user_agent = parse(request.headers.get("user-agent")) - request_ip = None - x_forwarded_for = request.headers.get("X-Forwarded-For") - if x_forwarded_for: - # 取第一个 IP 地址，通常为客户端真实 IP - request_ip = x_forwarded_for.split(",")[0].strip() - else: - # 若没有 X-Forwarded-For 头，则使用 request.client.host - request_ip = request.client.host if request.client else "127.0.0.1" + request_ip = _resolve_request_ip(request) login_location = await IpLocalUtil.resolve_location_for_log(request_ip) request.scope["login_location"] = login_location @@ -213,9 +284,6 @@ class LoginService: now = datetime.now() - # 记录租户信息到日志 - log.info(f"用户ID: {user.id}, 用户名: {user.username} 正在生成JWT令牌") - # 生成会话信息 session_info = OnlineOutSchema( session_id=session_id, @@ -272,7 +340,6 @@ class LoginService: cls, db: AsyncSession, redis: Redis, - request: Request, refresh_token: RefreshTokenPayloadSchema, ) -> JWTOutSchema: """ @@ -281,7 +348,6 @@ class LoginService: 参数: - db (AsyncSession): 数据库会话对象 - redis (Redis): Redis客户端对象 - - request (Request): FastAPI请求对象 - refresh_token (RefreshTokenPayloadSchema): 刷新令牌数据 返回: @@ -304,12 +370,11 @@ class LoginService: # 用户认证 auth = AuthSchema(db=db) - user = await UserCRUD(auth).get_by_id_crud(id=user_id) + user = await UserCRUD(auth).get(id=user_id) if not user: raise CustomException(msg="刷新token失败，用户不存在") - - # 记录刷新令牌时的租户信息 - log.info(f"用户ID: {user.id}, 用户名: {user.username} 正在刷新JWT令牌") + if user.status == 1: + raise CustomException(msg="用户已被停用") # 设置新的 token access_expires = timedelta(seconds=settings.ACCESS_TOKEN_EXPIRE_MINUTES) @@ -382,7 +447,7 @@ class LoginService: await RedisCURD(redis).delete(f"{RedisInitKeyConfig.ACCESS_TOKEN.key}:{session_id}") await RedisCURD(redis).delete(f"{RedisInitKeyConfig.REFRESH_TOKEN.key}:{session_id}") - log.info(f"用户退出登录成功,会话编号:{session_id}") + logger.info(f"用户退出登录成功,会话编号:{session_id}") return True @@ -416,7 +481,7 @@ class LoginService: if auth.user and auth.user.is_superuser: stmt = ( select(TenantModel) - .where(TenantModel.status == "0", TenantModel.is_deleted == 0) + .where(TenantModel.status == 0, TenantModel.is_deleted.is_(False)) .order_by(TenantModel.sort, TenantModel.id) ) result = await db.execute(stmt) @@ -429,7 +494,7 @@ class LoginService: .join(TenantUserModel, TenantUserModel.tenant_id == TenantModel.id) .where( TenantUserModel.user_id == uid, - TenantModel.status == "0", + TenantModel.status == 0, TenantModel.is_deleted.is_(False), ) .order_by(TenantUserModel.is_default.desc(), TenantModel.sort, TenantModel.id) @@ -486,7 +551,7 @@ class LoginService: # 验证租户是否存在且状态正常 tenant_stmt = ( select(TenantModel) - .where(TenantModel.id == tenant_id, TenantModel.status == "0") + .where(TenantModel.id == tenant_id, TenantModel.status == 0) .limit(1) ) result = await auth.db.execute(tenant_stmt) @@ -495,17 +560,10 @@ class LoginService: raise CustomException(msg="租户不存在或已被禁用") # 获取当前会话信息 - token = request.headers.get("Authorization", "").removeprefix("Bearer ").strip() - if not token: - raise CustomException(msg="无法获取当前Token") + session_id = request.scope.get("session_id") + session_info = request.scope.get("session_info") - from app.core.security import decode_access_token - - payload = decode_access_token(token) - session_info = json.loads(payload.sub) - session_id = session_info.get("session_id") - - if not session_id: + if not session_id or not session_info: raise CustomException(msg="会话已失效") # 更新会话信息中的 tenant_id @@ -534,12 +592,27 @@ class LoginService: expire=int(access_expires.total_seconds()), ) + # 同时签发并覆盖 refresh_token（含新 tenant_id）避免刷新时回退 + refresh_expires = timedelta(seconds=settings.REFRESH_TOKEN_EXPIRE_MINUTES) + new_refresh_token = create_access_token( + payload=JWTPayloadSchema( + sub=json.dumps(session_info), + is_refresh=True, + exp=now + refresh_expires, + ) + ) + await RedisCURD(redis).set( + key=f"{RedisInitKeyConfig.REFRESH_TOKEN.key}:{session_id}", + value=new_refresh_token, + expire=int(refresh_expires.total_seconds()), + ) + # 同时更新租户上下文 from app.core.tenant import set_current_tenant set_current_tenant(tenant_id, auth.user.is_superuser) - log.info( + logger.info( f"用户 {auth.user.username}(id={auth.user.id}) 切换到租户 {tenant.name}(id={tenant_id})" ) @@ -554,7 +627,7 @@ class CaptchaService: """验证码服务""" @classmethod - async def get_captcha_service(cls, redis: Redis) -> dict[str, CaptchaKey | CaptchaBase64]: + async def get_captcha_service(cls, redis: Redis) -> CaptchaOutSchema: """ 获取验证码 @@ -582,14 +655,12 @@ class CaptchaService: expire=settings.CAPTCHA_EXPIRE_SECONDS, ) - log.info(f"生成验证码成功,验证码:{captcha_value}") - # 返回验证码信息 return CaptchaOutSchema( enable=settings.CAPTCHA_ENABLE, key=CaptchaKey(captcha_key), img_base=CaptchaBase64(f"data:image/png;base64,{captcha_base64}"), - ).model_dump() + ) @classmethod async def check_captcha_service(cls, redis: Redis, key: str, captcha: str) -> bool: @@ -615,17 +686,14 @@ class CaptchaService: captcha_value = await RedisCURD(redis).get(redis_key) if not captcha_value: - log.error("验证码已过期或不存在") raise CustomException(msg="验证码已过期") # 验证码不区分大小写比对 if captcha.lower() != captcha_value.lower(): - log.error(f"验证码错误,用户输入:{captcha},正确值:{captcha_value}") raise CustomException(msg="验证码错误") # 验证成功后删除验证码,避免重复使用 await RedisCURD(redis).delete(redis_key) - log.info(f"验证码校验成功,key:{key}") return True @@ -655,7 +723,7 @@ class AutoLoginService: from app.api.v1.module_system.user.model import UserModel - stmt = select(UserModel).where(UserModel.status == "0") + stmt = select(UserModel).where(UserModel.status == 0) if tenant_id is not None: stmt = stmt.where(UserModel.tenant_id == tenant_id) stmt = stmt.order_by(UserModel.id) @@ -709,7 +777,7 @@ class AutoLoginService: if not user: raise CustomException(msg="用户不存在") - if user.status == "1": + if user.status == 1: raise CustomException(msg="用户已被停用") # 生成免登录Token @@ -731,7 +799,7 @@ class AutoLoginService: expire=cls.TOKEN_EXPIRE, ) - log.info(f"创建免登录Token成功,用户:{user.username}") + logger.info(f"创建免登录Token成功,用户:{user.username}") return AutoLoginTokenSchema( token=token, @@ -778,6 +846,9 @@ class AutoLoginService: if not token_data_str: raise CustomException(msg="免登录Token已过期或无效") + if isinstance(token_data_str, bytes): + token_data_str = token_data_str.decode("utf-8") + token_data = json.loads(token_data_str) user_id = token_data.get("user_id") token_tenant_id = token_data.get("tenant_id") @@ -792,7 +863,7 @@ class AutoLoginService: if not user: raise CustomException(msg="用户不存在") - if user.status == "1": + if user.status == 1: raise CustomException(msg="用户已被停用") # 删除已使用的Token @@ -803,6 +874,310 @@ class AutoLoginService: request=request, redis=redis, user=user, login_type="PC端" ) - log.info(f"用户{user.username}免登录成功") + logger.info(f"用户{user.username}免登录成功") return jwt_token + + +# ─── 租户自助注册 (PRD §4.5) ──────────────────────────────── + + +class TenantRegisterService: + """PRD §4.5 租户自助注册：一次性创建租户 + 管理员 + owner 角色 + 菜单分配""" + + DEFAULT_TRIAL_DAYS = 7 + + @classmethod + async def register( + cls, + db: AsyncSession, + username: str, + password: str, + email: str, + tenant_name: str | None = None, + ) -> TenantRegisterOutSchema: + from sqlalchemy import func, select + from sqlalchemy.exc import IntegrityError + + from app.api.v1.module_platform.package.model import PackageMenuModel, PackageModel + from app.api.v1.module_platform.tenant.model import TenantModel + from app.api.v1.module_system.role.model import RoleMenusModel, RoleModel + from app.api.v1.module_system.user.model import UserModel, UserRolesModel + + # ── 1. 唯一性校验 ── + exists_stmt = select(func.count()).select_from(UserModel).where( + UserModel.is_deleted.is_(False), + (UserModel.username == username) | (UserModel.email == email), + ) + cnt = (await db.execute(exists_stmt)).scalar() or 0 + if cnt > 0: + raise CustomException(msg="用户名或邮箱已被占用") + + # ── 2. 获取默认套餐 ── + pkg_stmt = select(PackageModel).where(PackageModel.status == 0).order_by(PackageModel.id).limit(1) + default_pkg = (await db.execute(pkg_stmt)).scalar_one_or_none() + + # ── 3. 计算试用期 ── + now = datetime.now() + trial_end = now + timedelta(days=cls.DEFAULT_TRIAL_DAYS) + + # ── 4. 生成租户 code ── + base = tenant_name or username + code_suffix = base.encode("utf-8").hex()[:6].upper() + tenant_code = f"T{code_suffix}" + + # ── 5. 创建租户 ── + tenant = TenantModel( + name=tenant_name or f"{username}的租户", + code=tenant_code, + contact_name=username, + package_id=default_pkg.id if default_pkg else None, + start_time=now, + end_time=trial_end, + status=0, + ) + db.add(tenant) + await db.flush() + + # ── 6. 创建管理员用户 ── + user = UserModel( + username=username, + password=PwdUtil.hash_password(password), + email=email, + tenant_id=tenant.id, + status=0, + ) + db.add(user) + await db.flush() + + # ── 7. 创建 owner 角色 ── + owner_role = RoleModel( + name="租户管理员", + code="owner", + tenant_id=tenant.id, + order=1, + data_scope=4, # 全部数据权限 + description="自助注册创建的管理员角色", + ) + db.add(owner_role) + await db.flush() + + # ── 8. 绑定用户角色 ── + user_role = UserRolesModel(user_id=user.id, role_id=owner_role.id) + db.add(user_role) + + # ── 9. 分配套餐菜单 ── + if default_pkg: + pkg_menu_stmt = select(PackageMenuModel).where( + PackageMenuModel.package_id == default_pkg.id, + ) + pkg_menus = (await db.execute(pkg_menu_stmt)).scalars().all() + for pm in pkg_menus: + db.add(RoleMenusModel(role_id=owner_role.id, menu_id=pm.menu_id)) + + try: + await db.commit() + except IntegrityError: + await db.rollback() + raise CustomException(msg="租户编码或用户名已被占用，请重试") + + # ── 10. 发送欢迎邮件 ── + try: + await cls._send_welcome_email(email, username, tenant.name, trial_end) + except Exception: + logger.warning(f"注册欢迎邮件发送失败: {email}") + + return TenantRegisterOutSchema( + user_id=user.id, + username=username, + tenant_id=tenant.id, + tenant_name=tenant.name, + tenant_code=tenant_code, + package=default_pkg.name if default_pkg else None, + trial_end=trial_end.strftime("%Y-%m-%d"), + message="注册成功", + ) + + @classmethod + async def _send_welcome_email( + cls, to_email: str, username: str, tenant_name: str, trial_end: datetime + ) -> None: + """发送欢迎邮件（不阻塞注册流程）。""" + from sqlalchemy import select + + from app.api.v1.module_platform.email.model import EmailConfigModel + from app.core.database import async_db_session + from app.utils.email_util import render_template, send_email + + async with async_db_session() as _db: + cfg_stmt = ( + select(EmailConfigModel) + .where( + EmailConfigModel.is_default.is_(True), + EmailConfigModel.status == 0, + ) + .limit(1) + ) + cfg = (await _db.execute(cfg_stmt)).scalar_one_or_none() + + if not cfg: + logger.info("无可用 SMTP 配置，跳过欢迎邮件") + return + + html_body = render_template( + """{{ username }}，您好！
+您的租户已成功创建，试用期至 {{ trial_end }}。
+请登录后台开始使用。
""", + { + "tenant_name": tenant_name, + "username": username, + "trial_end": trial_end.strftime("%Y-%m-%d"), + }, + ) + + await send_email( + smtp_host=cfg.smtp_host, + smtp_port=cfg.smtp_port, + smtp_user=cfg.smtp_user, + smtp_password=cfg.smtp_password, + use_tls=cfg.use_tls, + from_name=cfg.from_name, + to_email=to_email, + to_name=username, + subject=f"欢迎加入 {tenant_name}！", + body_html=html_body, + ) + logger.info(f"欢迎邮件已发送至 {to_email}") + + +# ─── 忘记密码自助重置 (PRD §4.6) ───────────────────────────── + + +class PasswordResetService: + """PRD §4.6 忘记密码：邮箱重置令牌 + 密码更新""" + + RESET_TOKEN_PREFIX = "pwd_reset:" + TOKEN_EXPIRE_SECONDS = 1800 # 30 分钟 + + @classmethod + async def forgot_password_service( + cls, redis: Redis, db: AsyncSession, email: str + ) -> str: + """ + 忘记密码：根据邮箱查找用户，生成重置令牌并尝试发送邮件。 + 无论邮箱是否存在均返回相同文案（防止邮箱探测攻击）。 + """ + from sqlalchemy import select + + from app.api.v1.module_system.user.model import UserModel + + stmt = select(UserModel).where( + UserModel.email == email, + UserModel.is_deleted.is_(False), + ) + result = await db.execute(stmt) + user = result.scalar_one_or_none() + + if not user: + logger.info(f"忘记密码：邮箱 {email} 未注册，静默返回") + return "若邮箱已注册，重置邮件已发送" + + # 生成一次性令牌 + token = secrets.token_urlsafe(32) + key = f"{cls.RESET_TOKEN_PREFIX}{token}" + await RedisCURD(redis).set( + key=key, value=str(user.id), expire=cls.TOKEN_EXPIRE_SECONDS + ) + + # 尝试发送邮件（不阻塞） + try: + await cls._send_reset_email(email, user.username, token) + except Exception: + logger.warning(f"密码重置邮件发送失败: {email}") + + return "若邮箱已注册，重置邮件已发送" + + @classmethod + async def reset_password_with_token_service( + cls, redis: Redis, db: AsyncSession, token: str, new_password: str + ) -> str: + """使用令牌重置密码。校验令牌 → 更新密码 → 删除令牌。""" + + from app.api.v1.module_system.user.model import UserModel + + key = f"{cls.RESET_TOKEN_PREFIX}{token}" + user_id_str = await RedisCURD(redis).get(key) + + if not user_id_str: + raise CustomException(msg="重置链接已失效，请重新申请") + + try: + user_id = int(user_id_str) + except (ValueError, TypeError): + await RedisCURD(redis).delete(key) + raise CustomException(msg="无效的重置链接") + + user = await db.get(UserModel, user_id) + if not user or user.is_deleted: + await RedisCURD(redis).delete(key) + raise CustomException(msg="用户不存在") + + user.password = PwdUtil.hash_password(new_password) + await db.commit() + await RedisCURD(redis).delete(key) + + logger.info(f"用户 {user.username}(id={user_id}) 密码已重置") + return "密码重置成功，请使用新密码登录" + + @classmethod + async def _send_reset_email(cls, to_email: str, username: str, token: str) -> None: + """发送密码重置邮件。""" + from sqlalchemy import select + + from app.api.v1.module_platform.email.model import EmailConfigModel + from app.core.database import async_db_session + from app.utils.email_util import render_template, send_email + + async with async_db_session() as _db: + cfg_stmt = ( + select(EmailConfigModel) + .where( + EmailConfigModel.is_default.is_(True), + EmailConfigModel.status == 0, + ) + .limit(1) + ) + cfg = (await _db.execute(cfg_stmt)).scalar_one_or_none() + + if not cfg: + logger.info("无可用 SMTP 配置，跳过重置邮件") + return + + reset_url = f"{getattr(settings, 'SITE_URL', '')}/reset-password?token={token}" + html_body = render_template( + """{{ username }}，您好！
+请点击以下链接重置密码（{{ expire_minutes }} 分钟内有效）：
+ +如果非您本人操作，请忽略此邮件。
""", + { + "username": username, + "reset_url": reset_url, + "expire_minutes": cls.TOKEN_EXPIRE_SECONDS // 60, + }, + ) + + await send_email( + smtp_host=cfg.smtp_host, + smtp_port=cfg.smtp_port, + smtp_user=cfg.smtp_user, + smtp_password=cfg.smtp_password, + use_tls=cfg.use_tls, + from_name=cfg.from_name, + to_email=to_email, + to_name=username, + subject="密码重置 - FastapiAdmin", + body_html=html_body, + ) + logger.info(f"密码重置邮件已发送至 {to_email}") diff --git a/backend/app/api/v1/module_system/dept/controller.py b/backend/app/api/v1/module_system/dept/controller.py index 22fced5d..2137fb86 100644 --- a/backend/app/api/v1/module_system/dept/controller.py +++ b/backend/app/api/v1/module_system/dept/controller.py @@ -2,29 +2,31 @@ from typing import Annotated from fastapi import APIRouter, Body, Depends, Path from fastapi.responses import JSONResponse +from fastapi_cache import FastAPICache +from fastapi_cache.decorator import cache -from app.api.v1.module_system.auth.schema import AuthSchema from app.common.response import ResponseSchema, SuccessResponse -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable from app.core.dependencies import AuthPermission -from app.core.logger import log from app.core.router_class import OperationLogRoute from .schema import DeptCreateSchema, DeptOutSchema, DeptQueryParam, DeptUpdateSchema from .service import DeptService -DeptRouter = APIRouter(route_class=OperationLogRoute, prefix="/dept", tags=["部门管理"]) +DeptRouter = APIRouter(route_class=OperationLogRoute, prefix="/dept", tags=["系统管理/部门管理"]) + +_DEPT_NS = "dept" @DeptRouter.get( "/tree", summary="查询部门树", - description="查询部门树", response_model=ResponseSchema[list[DeptOutSchema]], ) +@cache(expire=300, namespace=_DEPT_NS) async def get_dept_tree_controller( search: Annotated[DeptQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dept:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dept:query']))], ) -> JSONResponse: """ 查询部门树 @@ -43,19 +45,17 @@ async def get_dept_tree_controller( result_dict_list = await DeptService.get_dept_tree_service( search=search, auth=auth, order_by=order_by ) - log.info("查询部门树成功") return SuccessResponse(data=result_dict_list, msg="查询部门树成功") @DeptRouter.get( "/detail/{id}", summary="查询部门详情", - description="查询部门详情", response_model=ResponseSchema[DeptOutSchema], ) async def get_obj_detail_controller( id: Annotated[int, Path(description="部门ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dept:detail"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dept:detail']))], ) -> JSONResponse: """ 查询部门详情 @@ -71,19 +71,17 @@ async def get_obj_detail_controller( - CustomException: 查询部门详情失败时抛出异常。 """ result_dict = await DeptService.get_dept_detail_service(id=id, auth=auth) - log.info(f"查询部门详情成功 {id}") return SuccessResponse(data=result_dict, msg="查询部门详情成功") @DeptRouter.post( "/create", summary="创建部门", - description="创建部门", response_model=ResponseSchema[DeptOutSchema], ) async def create_obj_controller( data: DeptCreateSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dept:create"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dept:create']))], ) -> JSONResponse: """ 创建部门 @@ -99,20 +97,19 @@ async def create_obj_controller( - CustomException: 创建部门失败时抛出异常。 """ result_dict = await DeptService.create_dept_service(data=data, auth=auth) - log.info(f"创建部门成功: {result_dict}") + await FastAPICache.clear(namespace=_DEPT_NS) return SuccessResponse(data=result_dict, msg="创建部门成功") @DeptRouter.put( "/update/{id}", summary="修改部门", - description="修改部门", response_model=ResponseSchema[DeptOutSchema], ) async def update_obj_controller( data: DeptUpdateSchema, id: Annotated[int, Path(description="部门ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dept:update"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dept:update']))], ) -> JSONResponse: """ 修改部门 @@ -129,19 +126,18 @@ async def update_obj_controller( - CustomException: 修改部门失败时抛出异常。 """ result_dict = await DeptService.update_dept_service(auth=auth, id=id, data=data) - log.info(f"修改部门成功: {result_dict}") + await FastAPICache.clear(namespace=_DEPT_NS) return SuccessResponse(data=result_dict, msg="修改部门成功") @DeptRouter.delete( "/delete", summary="删除部门", - description="删除部门", response_model=ResponseSchema[None], ) async def delete_obj_controller( ids: Annotated[list[int], Body(description="ID列表")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dept:delete"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dept:delete']))], ) -> JSONResponse: """ 删除部门 @@ -157,19 +153,18 @@ async def delete_obj_controller( - CustomException: 删除部门失败时抛出异常。 """ await DeptService.delete_dept_service(ids=ids, auth=auth) - log.info(f"删除部门成功: {ids}") + await FastAPICache.clear(namespace=_DEPT_NS) return SuccessResponse(msg="删除部门成功") @DeptRouter.patch( "/status/batch", summary="批量修改部门状态", - description="批量修改部门状态", response_model=ResponseSchema[None], ) async def batch_set_available_obj_controller( data: BatchSetAvailable, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dept:patch"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dept:patch']))], ) -> JSONResponse: """ 批量修改部门状态 @@ -185,5 +180,5 @@ async def batch_set_available_obj_controller( - CustomException: 批量修改部门状态失败时抛出异常。 """ await DeptService.batch_set_available_service(data=data, auth=auth) - log.info(f"批量修改部门状态成功: {data.ids}") + await FastAPICache.clear(namespace=_DEPT_NS) return SuccessResponse(msg="批量修改部门状态成功") diff --git a/backend/app/api/v1/module_system/dept/crud.py b/backend/app/api/v1/module_system/dept/crud.py index 57e4276c..b39d0148 100644 --- a/backend/app/api/v1/module_system/dept/crud.py +++ b/backend/app/api/v1/module_system/dept/crud.py @@ -1,7 +1,7 @@ from collections.abc import Sequence -from app.api.v1.module_system.auth.schema import AuthSchema from app.core.base_crud import CRUDBase +from app.core.base_schema import AuthSchema from .model import DeptModel from .schema import DeptCreateSchema, DeptUpdateSchema @@ -20,45 +20,9 @@ class DeptCRUD(CRUDBase[DeptModel, DeptCreateSchema, DeptUpdateSchema]): 返回: - None """ - self.auth = auth super().__init__(model=DeptModel, auth=auth) - async def get_by_id_crud(self, id: int, preload: list | None = None) -> DeptModel | None: - """ - 根据 id 获取部门信息。 - - 参数: - - id (int): 部门 ID。 - - preload (list | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - DeptModel | None: 部门信息，未找到返回 None。 - """ - obj = await self.get(id=id, preload=preload) - if not obj: - return None - return obj - - async def get_list_crud( - self, - search: dict | None = None, - order_by: list[dict] | None = None, - preload: list | None = None, - ) -> Sequence[DeptModel]: - """ - 获取部门列表。 - - 参数: - - search (dict | None): 搜索条件。 - - order_by (list[dict] | None): 排序字段列表。 - - preload (list | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - Sequence[DeptModel]: 部门列表。 - """ - return await self.list(search=search, order_by=order_by, preload=preload) - - async def get_tree_list_crud( + async def get_tree_list( self, search: dict | None = None, order_by: list[dict] | None = None, @@ -81,29 +45,3 @@ class DeptCRUD(CRUDBase[DeptModel, DeptCreateSchema, DeptUpdateSchema]): children_attr="children", preload=preload, ) - - async def set_available_crud(self, ids: list[int], status: str) -> None: - """ - 批量设置部门可用状态。 - - 参数: - - ids (list[int]): 部门 ID 列表。 - - status (str): 可用状态。 - - 返回: - - None - """ - await self.set(ids=ids, status=status) - - async def get_name_crud(self, id: int) -> str | None: - """ - 根据 id 获取部门名称。 - - 参数: - - id (int): 部门 ID。 - - 返回: - - str | None: 部门名称，未找到返回 None。 - """ - obj = await self.get(id=id) - return obj.name if obj else None diff --git a/backend/app/api/v1/module_system/dept/schema.py b/backend/app/api/v1/module_system/dept/schema.py index fd91c6d1..a4d4c697 100644 --- a/backend/app/api/v1/module_system/dept/schema.py +++ b/backend/app/api/v1/module_system/dept/schema.py @@ -16,7 +16,7 @@ class DeptCreateSchema(BaseModel): phone: str | None = Field(default=None, max_length=20, description="联系电话") email: str | None = Field(default=None, max_length=128, description="邮箱") parent_id: int | None = Field(default=None, ge=0, description="父部门ID") - status: str = Field(default="0", max_length=1, description="状态(0:正常 1:禁用)") + status: int = Field(default=0, ge=0, le=1, description="状态(0:正常 1:禁用)") description: str | None = Field(default=None, max_length=255, description="备注") @field_validator("name") @@ -35,9 +35,9 @@ class DeptCreateSchema(BaseModel): @field_validator("status") @classmethod - def validate_status(cls, value: str): + def validate_status(cls, value: int): """校验状态：仅支持 0(正常)、1(禁用)""" - if value not in {"0", "1"}: + if value not in {0, 1}: raise ValueError("状态仅支持 0(正常) 或 1(禁用)") return value @@ -52,6 +52,7 @@ class DeptOutSchema(DeptCreateSchema, BaseSchema): model_config = ConfigDict(from_attributes=True) parent_name: str | None = Field(default=None, max_length=64, description="父部门名称") + children: list["DeptOutSchema"] | None = Field(default=None, description="子部门列表") class DeptQueryParam: diff --git a/backend/app/api/v1/module_system/dept/service.py b/backend/app/api/v1/module_system/dept/service.py index cedb4e1f..e0845bd2 100644 --- a/backend/app/api/v1/module_system/dept/service.py +++ b/backend/app/api/v1/module_system/dept/service.py @@ -1,12 +1,10 @@ -from app.api.v1.module_system.auth.schema import AuthSchema -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable from app.core.exceptions import CustomException from app.utils.common_util import ( get_child_id_map, get_child_recursion, get_parent_id_map, get_parent_recursion, - traversal_to_tree, ) from .crud import DeptCRUD @@ -24,7 +22,7 @@ class DeptService: """ @classmethod - async def get_dept_detail_service(cls, auth: AuthSchema, id: int) -> dict: + async def get_dept_detail_service(cls, auth: AuthSchema, id: int) -> DeptOutSchema: """ 获取部门详情。 @@ -35,13 +33,18 @@ class DeptService: 返回: - dict: 部门详情对象。 """ - dept = await DeptCRUD(auth).get_by_id_crud(id=id) - result = DeptOutSchema.model_validate(dept).model_dump() - if dept and dept.parent_id: + dept = await DeptCRUD(auth).get(id=id) + if not dept: + raise CustomException(msg="部门不存在") + # 从列属性构建 dict，避免 Pydantic 访问 ORM 关系触发 async 惰性加载 + dept_dict = {c.name: getattr(dept, c.name) for c in dept.__table__.columns} + dept_dict["children"] = None + dept_dict["parent_name"] = None + if dept.parent_id: parent = await DeptCRUD(auth).get(id=dept.parent_id) if parent: - result["parent_name"] = parent.name - return result + dept_dict["parent_name"] = parent.name + return DeptOutSchema(**dept_dict) @classmethod async def get_dept_tree_service( @@ -62,16 +65,16 @@ class DeptService: - list[dict]: 部门树形列表对象。 """ # 使用树形结构查询，预加载children关系 - dept_list = await DeptCRUD(auth).get_tree_list_crud( - search=search.__dict__, order_by=order_by + dept_list = await DeptCRUD(auth).get_tree_list( + search=search.__dict__ if search else {}, order_by=order_by ) - # 转换为字典列表 + # 转换为字典列表，tree_list 已通过 selectin 预加载 children dept_dict_list = [DeptOutSchema.model_validate(dept).model_dump() for dept in dept_list] - # 使用traversal_to_tree构建树形结构 - return traversal_to_tree(dept_dict_list) + # 仅保留根节点，子树已在 model_dump 中递归序列化 + return [d for d in dept_dict_list if d.get("parent_id") is None] @classmethod - async def create_dept_service(cls, auth: AuthSchema, data: DeptCreateSchema) -> dict: + async def create_dept_service(cls, auth: AuthSchema, data: DeptCreateSchema) -> DeptOutSchema: """ 创建部门。 @@ -97,10 +100,10 @@ class DeptService: await TenantService.check_quota_service(auth, auth.tenant_id, "dept") dept = await DeptCRUD(auth).create(data=data) - return DeptOutSchema.model_validate(dept).model_dump() + return DeptOutSchema.model_validate(dept) @classmethod - async def update_dept_service(cls, auth: AuthSchema, id: int, data: DeptUpdateSchema) -> dict: + async def update_dept_service(cls, auth: AuthSchema, id: int, data: DeptUpdateSchema) -> DeptOutSchema: """ 更新部门。 @@ -115,7 +118,7 @@ class DeptService: 异常: - CustomException: 当部门不存在或名称重复时抛出。 """ - dept = await DeptCRUD(auth).get_by_id_crud(id=id) + dept = await DeptCRUD(auth).get(id=id) if not dept: raise CustomException(msg="更新失败，该部门不存在") exist_dept = await DeptCRUD(auth).get(name=data.name) @@ -125,7 +128,7 @@ class DeptService: if exist_code and exist_code.id != id: raise CustomException(msg="更新失败，部门编码已存在") dept = await DeptCRUD(auth).update(id=id, data=data) - return DeptOutSchema.model_validate(dept).model_dump() + return DeptOutSchema.model_validate(dept) @classmethod async def delete_dept_service(cls, auth: AuthSchema, ids: list[int]) -> None: @@ -147,7 +150,7 @@ class DeptService: raise CustomException(msg="删除失败，删除对象不能为空") # 获取所有部门列表，用于构建树形关系 - all_depts = await DeptCRUD(auth).get_list_crud() + all_depts = await DeptCRUD(auth).list() # 构建子部门ID映射 child_id_map = get_child_id_map(model_list=all_depts) @@ -172,10 +175,10 @@ class DeptService: 返回: - None """ - dept_list = await DeptCRUD(auth).get_list_crud() + dept_list = await DeptCRUD(auth).list() total_ids = [] - if data.status == "0": + if data.status == 0: id_map = get_parent_id_map(model_list=dept_list) for dept_id in data.ids: enable_ids = get_parent_recursion(id=dept_id, id_map=id_map) @@ -186,4 +189,4 @@ class DeptService: disable_ids = get_child_recursion(id=dept_id, id_map=id_map) total_ids.extend(disable_ids) - await DeptCRUD(auth).set_available_crud(ids=total_ids, status=data.status) + await DeptCRUD(auth).set(ids=total_ids, status=data.status) diff --git a/backend/app/api/v1/module_system/dict/controller.py b/backend/app/api/v1/module_system/dict/controller.py index d8adab63..27769d2f 100644 --- a/backend/app/api/v1/module_system/dict/controller.py +++ b/backend/app/api/v1/module_system/dict/controller.py @@ -2,14 +2,14 @@ from typing import Annotated from fastapi import APIRouter, Body, Depends, Path from fastapi.responses import JSONResponse, StreamingResponse +from fastapi_cache import FastAPICache +from fastapi_cache.decorator import cache from redis.asyncio.client import Redis -from app.api.v1.module_system.auth.schema import AuthSchema from app.common.response import ResponseSchema, StreamResponse, SuccessResponse from app.core.base_params import PaginationQueryParam -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable, PageResultSchema from app.core.dependencies import AuthPermission, redis_getter -from app.core.logger import log from app.core.router_class import OperationLogRoute from app.utils.common_util import bytes2file_response @@ -25,18 +25,19 @@ from .schema import ( ) from .service import DictDataService, DictTypeService -DictRouter = APIRouter(route_class=OperationLogRoute, prefix="/dict", tags=["字典管理"]) +DictRouter = APIRouter(route_class=OperationLogRoute, prefix="/dict", tags=["系统管理/字典管理"]) + +_DICT_TYPE_NS = "dict_type" @DictRouter.get( "/type/detail/{id}", summary="获取字典类型详情", - description="获取字典类型详情", response_model=ResponseSchema[DictTypeOutSchema], ) async def get_type_detail_controller( id: Annotated[int, Path(description="字典类型ID", ge=1)], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:detail"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:detail']))], ) -> JSONResponse: """ 获取字典类型详情 @@ -52,20 +53,18 @@ async def get_type_detail_controller( - CustomException: 获取字典类型详情失败时抛出异常。 """ result_dict = await DictTypeService.get_obj_detail_service(id=id, auth=auth) - log.info(f"获取字典类型详情成功 {id}") return SuccessResponse(data=result_dict, msg="获取字典类型详情成功") @DictRouter.get( "/type/list", summary="查询字典类型", - description="查询字典类型", - response_model=ResponseSchema[list[DictTypeOutSchema]], + response_model=ResponseSchema[PageResultSchema[DictTypeOutSchema]], ) async def get_type_list_controller( page: Annotated[PaginationQueryParam, Depends()], search: Annotated[DictTypeQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:query']))], ) -> JSONResponse: """ 查询字典类型 @@ -88,18 +87,17 @@ async def get_type_list_controller( search=search, order_by=page.order_by, ) - log.info("查询字典类型列表成功") return SuccessResponse(data=result_dict, msg="查询字典类型列表成功") @DictRouter.get( "/type/optionselect", summary="获取全部字典类型", - description="获取全部字典类型", response_model=ResponseSchema[list[DictTypeOutSchema]], ) -async def get_type_loptionselect_controller( - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:query"]))], +@cache(expire=300, namespace=_DICT_TYPE_NS) +async def get_type_optionselect_controller( + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:query']))], ) -> JSONResponse: """ 获取全部字典类型 @@ -114,20 +112,18 @@ async def get_type_loptionselect_controller( - CustomException: 获取字典类型列表失败时抛出异常。 """ result_dict_list = await DictTypeService.get_obj_list_service(auth=auth) - log.info("获取字典类型列表成功") return SuccessResponse(data=result_dict_list, msg="获取字典类型列表成功") @DictRouter.post( "/type/create", summary="创建字典类型", - description="创建字典类型", response_model=ResponseSchema[DictTypeOutSchema], ) async def create_type_controller( data: DictTypeCreateSchema, redis: Annotated[Redis, Depends(redis_getter)], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:create"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:create']))], ) -> JSONResponse: """ 创建字典类型 @@ -144,21 +140,20 @@ async def create_type_controller( - CustomException: 创建字典类型失败时抛出异常。 """ result_dict = await DictTypeService.create_obj_service(auth=auth, redis=redis, data=data) - log.info(f"创建字典类型成功: {result_dict}") + await FastAPICache.clear(namespace=_DICT_TYPE_NS) return SuccessResponse(data=result_dict, msg="创建字典类型成功") @DictRouter.put( "/type/update/{id}", summary="修改字典类型", - description="修改字典类型", response_model=ResponseSchema[DictTypeOutSchema], ) async def update_type_controller( data: DictTypeUpdateSchema, redis: Annotated[Redis, Depends(redis_getter)], id: Annotated[int, Path(description="字典类型ID", ge=1)], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:update"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:update']))], ) -> JSONResponse: """ 修改字典类型 @@ -176,20 +171,19 @@ async def update_type_controller( - CustomException: 修改字典类型失败时抛出异常。 """ result_dict = await DictTypeService.update_obj_service(auth=auth, redis=redis, id=id, data=data) - log.info(f"修改字典类型成功: {result_dict}") + await FastAPICache.clear(namespace=_DICT_TYPE_NS) return SuccessResponse(data=result_dict, msg="修改字典类型成功") @DictRouter.delete( "/type/delete", summary="删除字典类型", - description="删除字典类型", response_model=ResponseSchema[None], ) async def delete_type_controller( redis: Annotated[Redis, Depends(redis_getter)], ids: Annotated[list[int], Body(description="ID列表")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:delete"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:delete']))], ) -> JSONResponse: """ 删除字典类型 @@ -206,19 +200,18 @@ async def delete_type_controller( - CustomException: 删除字典类型失败时抛出异常。 """ await DictTypeService.delete_obj_service(auth=auth, redis=redis, ids=ids) - log.info(f"删除字典类型成功: {ids}") + await FastAPICache.clear(namespace=_DICT_TYPE_NS) return SuccessResponse(msg="删除字典类型成功") @DictRouter.patch( "/type/status/batch", summary="批量修改字典类型状态", - description="批量修改字典类型状态", response_model=ResponseSchema[None], ) async def batch_set_available_dict_type_controller( data: BatchSetAvailable, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:patch"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:patch']))], ) -> JSONResponse: """ 批量修改字典类型状态 @@ -234,19 +227,18 @@ async def batch_set_available_dict_type_controller( - CustomException: 批量修改字典类型状态失败时抛出异常。 """ await DictTypeService.set_obj_available_service(auth=auth, data=data) - log.info(f"批量修改字典类型状态成功: {data.ids}") + await FastAPICache.clear(namespace=_DICT_TYPE_NS) return SuccessResponse(msg="批量修改字典类型状态成功") @DictRouter.post( "/type/export", summary="导出字典类型", - description="导出字典类型", response_model=ResponseSchema[None], ) async def export_type_list_controller( search: Annotated[DictTypeQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_type:export"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_type:export']))], ) -> StreamingResponse: """ 导出字典类型 @@ -261,10 +253,10 @@ async def export_type_list_controller( 异常: - CustomException: 导出字典类型失败时抛出异常。 """ - # 获取全量数据 + # 获取全量数据并转为dict列表 result_dict_list = await DictTypeService.get_obj_list_service(search=search, auth=auth) - export_result = await DictTypeService.export_obj_service(data_list=result_dict_list) - log.info("导出字典类型成功") + export_data = [item.model_dump() for item in result_dict_list] + export_result = await DictTypeService.export_obj_service(data_list=export_data) return StreamResponse( data=bytes2file_response(export_result), @@ -276,12 +268,11 @@ async def export_type_list_controller( @DictRouter.get( "/data/detail/{id}", summary="获取字典数据详情", - description="获取字典数据详情", response_model=ResponseSchema[DictDataOutSchema], ) async def get_data_detail_controller( id: Annotated[int, Path(description="字典数据ID", ge=1)], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_data:detail"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_data:detail']))], ) -> JSONResponse: """ 获取字典数据详情 @@ -297,20 +288,18 @@ async def get_data_detail_controller( - CustomException: 获取字典数据详情失败时抛出异常。 """ result_dict = await DictDataService.get_obj_detail_service(id=id, auth=auth) - log.info(f"获取字典数据详情成功 {id}") return SuccessResponse(data=result_dict, msg="获取字典数据详情成功") @DictRouter.get( "/data/list", summary="查询字典数据", - description="查询字典数据", - response_model=ResponseSchema[list[DictDataOutSchema]], + response_model=ResponseSchema[PageResultSchema[DictDataOutSchema]], ) async def get_data_list_controller( page: Annotated[PaginationQueryParam, Depends()], search: Annotated[DictDataQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_data:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_data:query']))], ) -> JSONResponse: """ 查询字典数据 @@ -336,20 +325,18 @@ async def get_data_list_controller( search=search, order_by=order_by, ) - log.info("查询字典数据列表成功") return SuccessResponse(data=result_dict, msg="查询字典数据列表成功") @DictRouter.post( "/data/create", summary="创建字典数据", - description="创建字典数据", response_model=ResponseSchema[DictDataOutSchema], ) async def create_data_controller( data: DictDataCreateSchema, redis: Annotated[Redis, Depends(redis_getter)], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_data:create"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_data:create']))], ) -> JSONResponse: """ 创建字典数据 @@ -366,21 +353,19 @@ async def create_data_controller( - CustomException: 创建字典数据失败时抛出异常。 """ result_dict = await DictDataService.create_obj_service(auth=auth, redis=redis, data=data) - log.info(f"创建字典数据成功: {result_dict}") return SuccessResponse(data=result_dict, msg="创建字典数据成功") @DictRouter.put( "/data/update/{id}", summary="修改字典数据", - description="修改字典数据", response_model=ResponseSchema[DictDataOutSchema], ) async def update_data_controller( data: DictDataUpdateSchema, redis: Annotated[Redis, Depends(redis_getter)], id: Annotated[int, Path(description="字典数据ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_data:update"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_data:update']))], ) -> JSONResponse: """ 修改字典数据 @@ -398,20 +383,18 @@ async def update_data_controller( - CustomException: 修改字典数据失败时抛出异常。 """ result_dict = await DictDataService.update_obj_service(auth=auth, redis=redis, id=id, data=data) - log.info(f"修改字典数据成功: {result_dict}") return SuccessResponse(data=result_dict, msg="修改字典数据成功") @DictRouter.delete( "/data/delete", summary="删除字典数据", - description="删除字典数据", response_model=ResponseSchema[None], ) async def delete_data_controller( redis: Annotated[Redis, Depends(redis_getter)], ids: Annotated[list[int], Body(description="ID列表")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_data:delete"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_data:delete']))], ) -> JSONResponse: """ 删除字典数据 @@ -428,19 +411,17 @@ async def delete_data_controller( - CustomException: 删除字典数据失败时抛出异常。 """ await DictDataService.delete_obj_service(auth=auth, redis=redis, ids=ids) - log.info(f"删除字典数据成功: {ids}") return SuccessResponse(msg="删除字典数据成功") @DictRouter.patch( "/data/status/batch", summary="批量修改字典数据状态", - description="批量修改字典数据状态", response_model=ResponseSchema[None], ) async def batch_set_available_dict_data_controller( data: BatchSetAvailable, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_data:patch"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_data:patch']))], ) -> JSONResponse: """ 批量修改字典数据状态 @@ -456,20 +437,18 @@ async def batch_set_available_dict_data_controller( - CustomException: 批量修改字典数据状态失败时抛出异常。 """ await DictDataService.set_obj_available_service(auth=auth, data=data) - log.info(f"批量修改字典数据状态成功: {data.ids}") return SuccessResponse(msg="批量修改字典数据状态成功") @DictRouter.post( "/data/export", summary="导出字典数据", - description="导出字典数据", response_model=ResponseSchema[None], ) async def export_data_list_controller( search: Annotated[DictDataQueryParam, Depends()], page: Annotated[PaginationQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:dict_data:export"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:dict_data:export']))], ) -> StreamingResponse: """ 导出字典数据 @@ -488,8 +467,8 @@ async def export_data_list_controller( result_dict_list = await DictDataService.get_obj_list_service( auth=auth, search=search, order_by=page.order_by ) - export_result = await DictDataService.export_obj_service(data_list=result_dict_list) - log.info("导出字典数据成功") + export_data = [item.model_dump() for item in result_dict_list] + export_result = await DictDataService.export_obj_service(data_list=export_data) return StreamResponse( data=bytes2file_response(export_result), @@ -501,7 +480,6 @@ async def export_data_list_controller( @DictRouter.get( "/data/info/{dict_type}", summary="根据字典类型获取数据", - description="根据字典类型获取数据", response_model=ResponseSchema[list[DictDataOutSchema]], ) async def get_init_dict_data_controller( @@ -523,6 +501,5 @@ async def get_init_dict_data_controller( dict_data_query_result = await DictDataService.get_init_dict_service( redis=redis, dict_type=dict_type, tenant_id=1 ) - log.info(f"获取初始化字典数据成功：{dict_data_query_result}") return SuccessResponse(data=dict_data_query_result, msg="获取初始化字典数据成功") diff --git a/backend/app/api/v1/module_system/dict/crud.py b/backend/app/api/v1/module_system/dict/crud.py index 4514954f..488b6d11 100644 --- a/backend/app/api/v1/module_system/dict/crud.py +++ b/backend/app/api/v1/module_system/dict/crud.py @@ -1,6 +1,5 @@ from collections.abc import Sequence -from app.api.v1.module_system.auth.schema import AuthSchema from app.api.v1.module_system.dict.model import DictDataModel, DictTypeModel from app.api.v1.module_system.dict.schema import ( DictDataCreateSchema, @@ -9,6 +8,7 @@ from app.api.v1.module_system.dict.schema import ( DictTypeUpdateSchema, ) from app.core.base_crud import CRUDBase +from app.core.base_schema import AuthSchema class DictTypeCRUD(CRUDBase[DictTypeModel, DictTypeCreateSchema, DictTypeUpdateSchema]): @@ -24,112 +24,8 @@ class DictTypeCRUD(CRUDBase[DictTypeModel, DictTypeCreateSchema, DictTypeUpdateS 返回: - None """ - self.auth = auth super().__init__(model=DictTypeModel, auth=auth) - async def get_obj_by_id_crud( - self, id: int, preload: list | None = None - ) -> DictTypeModel | None: - """ - 获取数据字典类型详情 - - 参数: - - id (int): 数据字典类型ID - - preload (list | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - DictTypeModel | None: 数据字典类型模型,如果不存在则为None - """ - # 添加默认预加载字典数据关系 - if preload is None: - preload = [] - return await self.get(id=id, preload=preload) - - async def get_obj_list_crud( - self, - search: dict | None = None, - order_by: list[dict] | None = None, - preload: list | None = None, - ) -> Sequence[DictTypeModel]: - """ - 获取数据字典类型列表 - - 参数: - - search (dict | None): 查询参数,默认值为None - - order_by (list[dict] | None): 排序参数,默认值为None - - preload (list | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - Sequence[DictTypeModel]: 数据字典类型模型序列 - """ - # 添加默认预加载字典数据关系 - if preload is None: - preload = [] - return await self.list(search=search, order_by=order_by, preload=preload) - - async def create_obj_crud(self, data: DictTypeCreateSchema) -> DictTypeModel | None: - """ - 创建数据字典类型 - - 参数: - - data (DictTypeCreateSchema): 数据字典类型创建模型 - - 返回: - - DictTypeModel | None: 创建的数据字典类型模型,如果创建失败则为None - """ - return await self.create(data=data) - - async def update_obj_crud(self, id: int, data: DictTypeUpdateSchema) -> DictTypeModel | None: - """ - 更新数据字典类型 - - 参数: - - id (int): 数据字典类型ID - - data (DictTypeUpdateSchema): 数据字典类型更新模型 - - 返回: - - DictTypeModel | None: 更新的数据字典类型模型,如果更新失败则为None - """ - return await self.update(id=id, data=data) - - async def delete_obj_crud(self, ids: list[int]) -> None: - """ - 删除数据字典类型 - - 参数: - - ids (list[int]): 数据字典类型ID列表 - - 返回: - - None - """ - return await self.delete(ids=ids) - - async def set_obj_available_crud(self, ids: list[int], status: str) -> None: - """ - 设置数据字典类型的可用状态 - - 参数: - - ids (list[int]): 数据字典类型ID列表 - - status (str): 可用状态,0表示正常,1表示停用 - - 返回: - - None - """ - return await self.set(ids=ids, status=status) - - async def batch_delete_obj_crud(self, ids: list[int]) -> int: - """ - 批量删除数据字典类型 - - 参数: - - ids (list[int]): 数据字典类型ID列表 - - 返回: - - int: 删除的记录数量 - """ - await self.delete(ids=ids) - return len(ids) - class DictDataCRUD(CRUDBase[DictDataModel, DictDataCreateSchema, DictDataUpdateSchema]): """数据字典数据层""" @@ -144,100 +40,11 @@ class DictDataCRUD(CRUDBase[DictDataModel, DictDataCreateSchema, DictDataUpdateS 返回: - None """ - self.auth = auth super().__init__(model=DictDataModel, auth=auth) - async def get_obj_by_id_crud( - self, id: int, preload: list | None = None - ) -> DictDataModel | None: - """ - 获取数据字典数据详情 - - 参数: - - id (int): 数据字典数据ID - - preload (list | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - DictDataModel | None: 数据字典数据模型,如果不存在则为None - """ - # 添加默认预加载字典类型关系 - if preload is None: - preload = [] - return await self.get(id=id, preload=preload) - - async def get_obj_list_crud( - self, - search: dict | None = None, - order_by: list[dict] | None = None, - preload: list | None = None, - ) -> Sequence[DictDataModel]: - """ - 获取数据字典数据列表 - - 参数: - - search (dict | None): 查询参数,默认值为None - - order_by (list[dict] | None): 排序参数,默认值为None - - preload (list | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - Sequence[DictDataModel]: 数据字典数据模型序列 - """ - # 添加默认预加载字典类型关系 - if preload is None: - preload = [] - return await self.list(search=search, order_by=order_by, preload=preload) - - async def create_obj_crud(self, data: DictDataCreateSchema) -> DictDataModel | None: - """ - 创建数据字典数据 - - 参数: - - data (DictDataCreateSchema): 数据字典数据创建模型 - - 返回: - - DictDataModel | None: 创建的数据字典数据模型,如果创建失败则为None - """ - return await self.create(data=data) - - async def update_obj_crud(self, id: int, data: DictDataUpdateSchema) -> DictDataModel | None: - """ - 更新数据字典数据 - - 参数: - - id (int): 数据字典数据ID - - data (DictDataUpdateSchema): 数据字典数据更新模型 - - 返回: - - DictDataModel | None: 更新的数据字典数据模型,如果更新失败则为None - """ - return await self.update(id=id, data=data) - - async def delete_obj_crud(self, ids: list[int]) -> None: - """ - 删除数据字典数据 - - 参数: - - ids (list[int]): 数据字典数据ID列表 - - 返回: - - None - """ - return await self.delete(ids=ids) - - async def set_obj_available_crud(self, ids: list[int], status: str) -> None: - """ - 设置数据字典数据的可用状态 - - 参数: - - ids (list[int]): 数据字典数据ID列表 - - status (str): 可用状态,0表示正常,1表示停用 - - 返回: - - None - """ - return await self.set(ids=ids, status=status) - - async def batch_delete_obj_crud(self, ids: list[int], exclude_system: bool = True) -> int: + async def batch_delete( + self, ids: list[int], exclude_system: bool = True + ) -> int: """ 批量删除数据字典数据 @@ -248,25 +55,20 @@ class DictDataCRUD(CRUDBase[DictDataModel, DictDataCreateSchema, DictDataUpdateS 返回: - int: 删除的记录数量 """ - # 如果需要排除系统默认数据，可以在这里添加过滤逻辑 - # 假设系统默认数据在remark字段中包含"系统默认"字符串 if exclude_system: - # 获取非系统默认数据的ID - system_data_filter = { + system_data = await self.list(search={ "id__in": ids, "remark__contains": "系统默认", - } - system_data = await self.list(search=system_data_filter) + }) system_ids = [item.id for item in system_data] - # 从待删除ID列表中排除系统默认数据 ids = [id for id in ids if id not in system_ids] if ids: await self.delete(ids=ids) return len(ids) - async def get_obj_list_by_dict_type_crud( - self, dict_type: str, status: str | None = "0" + async def get_list_by_dict_type( + self, dict_type: str, status: int | None = 0 ) -> Sequence[DictDataModel]: """ 根据字典类型获取字典数据列表 @@ -281,5 +83,4 @@ class DictDataCRUD(CRUDBase[DictDataModel, DictDataCreateSchema, DictDataUpdateS search = {"dict_type": dict_type} if status is not None: search["status"] = status - order_by = [{"id": "asc"}] - return await self.list(search=search, order_by=order_by) + return await self.list(search=search, order_by=[{"id": "asc"}]) diff --git a/backend/app/api/v1/module_system/dict/schema.py b/backend/app/api/v1/module_system/dict/schema.py index 6df3ae34..2e0614f3 100644 --- a/backend/app/api/v1/module_system/dict/schema.py +++ b/backend/app/api/v1/module_system/dict/schema.py @@ -21,17 +21,18 @@ class DictTypeCreateSchema(BaseModel): dict_name: str = Field(..., min_length=1, max_length=64, description="字典名称") dict_type: str = Field(..., min_length=1, max_length=255, description="字典类型编码") - status: str = Field(default="0", max_length=1, description="状态(0:正常 1:停用)") + status: int = Field(default=0, ge=0, le=1, description="状态(0:正常 1:停用)") description: str | None = Field(default=None, max_length=255, description="描述") @field_validator("status") @classmethod - def validate_status(cls, value: str): - if value not in {"0", "1"}: + def validate_status(cls, value: int): + if value not in {0, 1}: raise ValueError("状态仅支持 0(正常) 或 1(停用)") return value @field_validator("dict_name") + @classmethod def validate_dict_name(cls, value: str): """ 校验字典名称为非空字符串。 @@ -50,6 +51,7 @@ class DictTypeCreateSchema(BaseModel): return value.strip() @field_validator("dict_type") + @classmethod def validate_dict_type(cls, value: str): """ 校验字典类型：小写字母开头，仅包含小写字母/数字/下划线。 @@ -100,7 +102,6 @@ class DictTypeQueryParam: examples=["2025-01-01 00:00:00", "2025-12-31 23:59:59"], ), ) -> None: - super().__init__() # 模糊查询字段 self.dict_name = (QueueEnum.like.value, dict_name) @@ -131,13 +132,13 @@ class DictDataCreateSchema(BaseModel): ) list_class: str | None = Field(default=None, max_length=255, description="表格回显样式") is_default: bool = Field(default=False, description="是否默认") - status: str = Field(default="0", max_length=1, description="状态(0:正常 1:停用)") + status: int = Field(default=0, ge=0, le=1, description="状态(0:正常 1:停用)") description: str | None = Field(default=None, max_length=255, description="描述") @field_validator("status") @classmethod - def validate_status(cls, value: str): - if value not in {"0", "1"}: + def validate_status(cls, value: int) -> int: + if value not in (0, 1): raise ValueError("状态仅支持 0(正常) 或 1(停用)") return value diff --git a/backend/app/api/v1/module_system/dict/service.py b/backend/app/api/v1/module_system/dict/service.py index 40b417e8..71744e2d 100644 --- a/backend/app/api/v1/module_system/dict/service.py +++ b/backend/app/api/v1/module_system/dict/service.py @@ -2,12 +2,11 @@ import json from redis.asyncio.client import Redis -from app.api.v1.module_system.auth.schema import AuthSchema from app.common.enums import RedisInitKeyConfig -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable from app.core.database import async_db_session from app.core.exceptions import CustomException -from app.core.logger import log +from app.core.logger import logger from app.core.redis_crud import RedisCURD from app.utils.excel_util import ExcelUtil @@ -30,7 +29,7 @@ class DictTypeService: """ @classmethod - async def get_obj_detail_service(cls, auth: AuthSchema, id: int) -> dict: + async def get_obj_detail_service(cls, auth: AuthSchema, id: int) -> DictTypeOutSchema: """ 获取数据字典类型详情 @@ -41,8 +40,10 @@ class DictTypeService: 返回: - dict: 数据字典类型详情字典 """ - obj = await DictTypeCRUD(auth).get_obj_by_id_crud(id=id) - return DictTypeOutSchema.model_validate(obj).model_dump() + obj = await DictTypeCRUD(auth).get(id=id) + if not obj: + raise CustomException(msg="字典类型不存在") + return DictTypeOutSchema.model_validate(obj) @classmethod async def get_obj_list_service( @@ -50,7 +51,7 @@ class DictTypeService: auth: AuthSchema, search: DictTypeQueryParam | None = None, order_by: list[dict] | None = None, - ) -> list[dict]: + ) -> list[DictTypeOutSchema]: """ 获取数据字典类型列表 @@ -60,12 +61,12 @@ class DictTypeService: - order_by (list[dict] | None): 排序字段列表 返回: - - list[dict]: 数据字典类型详情字典列表 + - list[DictTypeOutSchema]: 数据字典类型 """ - obj_list = await DictTypeCRUD(auth).get_obj_list_crud( - search=search.__dict__, order_by=order_by + obj_list = await DictTypeCRUD(auth).list( + search=search.__dict__ if search else {}, order_by=order_by ) - return [DictTypeOutSchema.model_validate(obj).model_dump() for obj in obj_list] + return [DictTypeOutSchema.model_validate(obj) for obj in obj_list] @classmethod async def get_obj_page_service( @@ -101,7 +102,7 @@ class DictTypeService: @classmethod async def create_obj_service( cls, auth: AuthSchema, redis: Redis, data: DictTypeCreateSchema - ) -> dict: + ) -> DictTypeOutSchema: """ 创建数据字典类型 @@ -116,21 +117,21 @@ class DictTypeService: exist_obj = await DictTypeCRUD(auth).get(dict_name=data.dict_name) if exist_obj: raise CustomException(msg="创建失败，该数据字典类型已存在") - obj = await DictTypeCRUD(auth).create_obj_crud(data=data) + obj = await DictTypeCRUD(auth).create(data=data) - new_obj_dict = DictTypeOutSchema.model_validate(obj).model_dump() + new_obj_dict = DictTypeOutSchema.model_validate(obj) redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:{auth.user.tenant_id}:{data.dict_type}" try: await RedisCURD(redis).set( key=redis_key, - value="", + value="[]", expire=None, ) - log.info(f"创建字典类型成功: {new_obj_dict}") + logger.info(f"创建字典类型成功: {new_obj_dict}") except Exception as e: - log.error(f"创建字典类型失败: {e}") + logger.error(f"创建字典类型失败: {e}") raise CustomException(msg=f"创建字典类型失败 {e}") return new_obj_dict @@ -142,7 +143,7 @@ class DictTypeService: redis: Redis, id: int, data: DictTypeUpdateSchema, - ) -> dict: + ) -> DictTypeOutSchema: """ 更新数据字典类型 @@ -155,16 +156,14 @@ class DictTypeService: 返回: - dict: 数据字典类型详情字典 """ - exist_obj = await DictTypeCRUD(auth).get_obj_by_id_crud(id=id) + exist_obj = await DictTypeCRUD(auth).get(id=id) if not exist_obj: raise CustomException(msg="更新失败，该数据字典类型不存在") if exist_obj.dict_name != data.dict_name: raise CustomException(msg="更新失败，数据字典类型名称不可以修改") - dict_data_list = [] - # 如果字典类型修改或状态变更，则修改对应字典数据的类型和状态，并更新Redis缓存 + # 如果字典类型修改或状态变更，则修改对应字典数据的类型和状态 if exist_obj.dict_type != data.dict_type or exist_obj.status != data.status: - # 检查字典数据类型是否被修改 exist_obj_type_list = await DictDataCRUD(auth).list( search={"dict_type": exist_obj.dict_type} ) @@ -183,17 +182,16 @@ class DictTypeService: status=data.status, description=item.description, ) - obj = await DictDataCRUD(auth).update_obj_crud(id=item.id, data=dict_data) - dict_data_list.append(DictDataOutSchema.model_validate(obj).model_dump()) + await DictDataCRUD(auth).update(id=item.id, data=dict_data) - obj = await DictTypeCRUD(auth).update_obj_crud(id=id, data=data) + obj = await DictTypeCRUD(auth).update(id=id, data=data) - new_obj_dict = DictTypeOutSchema.model_validate(obj).model_dump() + new_obj_dict = DictTypeOutSchema.model_validate(obj) redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:{auth.user.tenant_id}:{data.dict_type}" try: # 获取当前字典类型的所有字典数据，确保包含最新状态 - dict_data_list = await DictDataCRUD(auth).get_obj_list_crud( + dict_data_list = await DictDataCRUD(auth).list( search={"dict_type": data.dict_type} ) dict_data = [ @@ -208,9 +206,9 @@ class DictTypeService: value=value, expire=None, ) - log.info(f"更新字典类型成功并刷新缓存: {new_obj_dict}") + logger.info(f"更新字典类型成功并刷新缓存: {new_obj_dict}") except Exception as e: - log.error(f"更新字典类型缓存失败: {e}") + logger.error(f"更新字典类型缓存失败: {e}") raise CustomException(msg=f"更新字典类型缓存失败 {e}") return new_obj_dict @@ -230,12 +228,14 @@ class DictTypeService: """ if len(ids) < 1: raise CustomException(msg="删除失败，删除对象不能为空") - for id in ids: - exist_obj = await DictTypeCRUD(auth).get_obj_by_id_crud(id=id) - if not exist_obj: + existing = await DictTypeCRUD(auth).list(search={"id": ("in", ids)}) + existing_map = {obj.id: obj for obj in existing} + for nid in ids: + if nid not in existing_map: raise CustomException(msg="删除失败，该数据字典类型不存在") + exist_obj = existing_map[nid] # 检查是否有字典数据 - exist_obj_type_list = await DictDataCRUD(auth).list(search={"dict_type": id}) + exist_obj_type_list = await DictDataCRUD(auth).list(search={"dict_type": exist_obj.dict_type}) if len(exist_obj_type_list) > 0: # 如果有字典数据，不能删除 raise CustomException(msg="删除失败，该数据字典类型下存在字典数据") @@ -245,11 +245,11 @@ class DictTypeService: ) try: await RedisCURD(redis).delete(redis_key) - log.info(f"删除字典类型成功: {id}") + logger.info(f"删除字典类型成功: {nid}") except Exception as e: - log.error(f"删除字典类型失败: {e}") + logger.error(f"删除字典类型失败: {e}") raise CustomException(msg="删除字典类型失败") - await DictTypeCRUD(auth).delete_obj_crud(ids=ids) + await DictTypeCRUD(auth).delete(ids=ids) @classmethod async def set_obj_available_service(cls, auth: AuthSchema, data: BatchSetAvailable) -> None: @@ -263,7 +263,7 @@ class DictTypeService: 返回: - None """ - await DictTypeCRUD(auth).set_obj_available_crud(ids=data.ids, status=data.status) + await DictTypeCRUD(auth).set(ids=data.ids, status=data.status) @classmethod async def export_obj_service(cls, data_list: list[dict]) -> bytes: @@ -292,12 +292,7 @@ class DictTypeService: data = data_list.copy() for item in data: # 处理状态 - item["status"] = "启用" if item.get("status") == "0" else "停用" - item["creator"] = ( - item.get("creator", {}).get("name", "未知") - if isinstance(item.get("creator"), dict) - else "未知" - ) + item["status"] = "启用" if item.get("status") == 0 else "停用" return ExcelUtil.export_list2excel(list_data=data, mapping_dict=mapping_dict) @@ -308,7 +303,7 @@ class DictDataService: """ @classmethod - async def get_obj_detail_service(cls, auth: AuthSchema, id: int) -> dict: + async def get_obj_detail_service(cls, auth: AuthSchema, id: int) -> DictDataOutSchema: """ 获取数据字典数据详情 @@ -319,8 +314,10 @@ class DictDataService: 返回: - dict: 数据字典数据详情字典 """ - obj = await DictDataCRUD(auth).get_obj_by_id_crud(id=id) - return DictDataOutSchema.model_validate(obj).model_dump() + obj = await DictDataCRUD(auth).get(id=id) + if not obj: + raise CustomException(msg="字典数据不存在") + return DictDataOutSchema.model_validate(obj) @classmethod async def get_obj_list_service( @@ -328,7 +325,7 @@ class DictDataService: auth: AuthSchema, search: DictDataQueryParam | None = None, order_by: list[dict] | None = None, - ) -> list[dict]: + ) -> list[DictDataOutSchema]: """ 获取数据字典数据列表 @@ -338,12 +335,12 @@ class DictDataService: - order_by (list[dict] | None): 排序字段列表 返回: - - list[dict]: 数据字典数据详情字典列表 + - list[DictDataOutSchema]: 数据字典数据 """ - obj_list = await DictDataCRUD(auth).get_obj_list_crud( - search=search.__dict__, order_by=order_by + obj_list = await DictDataCRUD(auth).list( + search=search.__dict__ if search else {}, order_by=order_by ) - return [DictDataOutSchema.model_validate(obj).model_dump() for obj in obj_list] + return [DictDataOutSchema.model_validate(obj) for obj in obj_list] @classmethod async def get_obj_page_service( @@ -391,16 +388,16 @@ class DictDataService: async with async_db_session() as session: async with session.begin(): auth = AuthSchema(db=session, check_data_scope=False) - obj_list = await DictTypeCRUD(auth).get_obj_list_crud() + obj_list = await DictTypeCRUD(auth).list() if not obj_list: - log.warning("未找到任何字典类型数据") + logger.warning("未找到任何字典类型数据") return for obj in obj_list: dict_type = obj.dict_type tenant_id = obj.tenant_id try: - dict_data_list = await DictDataCRUD(auth).get_obj_list_crud( + dict_data_list = await DictDataCRUD(auth).list( search={"dict_type": dict_type, "tenant_id": tenant_id} ) dict_data = [ @@ -418,10 +415,10 @@ class DictDataService: expire=None, ) except Exception as e: - log.error(f"❌ 初始化字典数据失败 [{dict_type}]: {e}") + logger.error(f"❌ 初始化字典数据失败 [{dict_type}]: {e}") except Exception as e: - log.error(f"字典初始化过程发生错误: {e}") + logger.error(f"字典初始化过程发生错误: {e}") raise CustomException(msg=f"字典数据初始化失败: {e!s}") @classmethod @@ -448,7 +445,7 @@ class DictDataService: try: return json.loads(obj_list_dict) except json.JSONDecodeError: - log.warning(f"字典数据反序列化失败，尝试重新初始化缓存: {dict_type}") + logger.warning(f"字典数据反序列化失败，尝试重新初始化缓存: {dict_type}") elif isinstance(obj_list_dict, list): return obj_list_dict @@ -467,13 +464,13 @@ class DictDataService: except CustomException: raise except Exception as e: - log.error(f"获取字典缓存失败: {e!s}") + logger.error(f"获取字典缓存失败: {e!s}") raise CustomException(msg=f"获取字典数据失败: {e!s}") @classmethod async def create_obj_service( cls, auth: AuthSchema, redis: Redis, data: DictDataCreateSchema - ) -> dict: + ) -> DictDataOutSchema: """ 创建数据字典数据 @@ -499,12 +496,12 @@ class DictDataService: if exist_value_obj: raise CustomException(msg=f'创建失败，该字典类型下的字典键值"{data.dict_value}"已存在') - obj = await DictDataCRUD(auth).create_obj_crud(data=data) + obj = await DictDataCRUD(auth).create(data=data) redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:{auth.user.tenant_id}:{data.dict_type}" try: # 获取当前字典类型的所有字典数据 - dict_data_list = await DictDataCRUD(auth).get_obj_list_crud( + dict_data_list = await DictDataCRUD(auth).list( search={"dict_type": data.dict_type} ) dict_data = [ @@ -519,12 +516,12 @@ class DictDataService: value=value, expire=None, ) - log.info(f"创建字典数据写入缓存成功: {obj}") + logger.info(f"创建字典数据写入缓存成功: {obj}") except Exception as e: - log.error(f"创建字典数据写入缓存失败: {e}") + logger.error(f"创建字典数据写入缓存失败: {e}") raise CustomException(msg=f"创建字典数据失败 {e}") - return DictDataOutSchema.model_validate(obj).model_dump() + return DictDataOutSchema.model_validate(obj) @classmethod async def update_obj_service( @@ -533,7 +530,7 @@ class DictDataService: redis: Redis, id: int, data: DictDataUpdateSchema, - ) -> dict: + ) -> DictDataOutSchema: """ 更新数据字典数据 @@ -546,7 +543,7 @@ class DictDataService: 返回: - Dict: 数据字典数据详情字典 """ - exist_obj = await DictDataCRUD(auth).get_obj_by_id_crud(id=id) + exist_obj = await DictDataCRUD(auth).get(id=id) if not exist_obj: raise CustomException(msg="更新失败，该字典数据不存在") @@ -576,7 +573,7 @@ class DictDataService: if dict_type: redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:{auth.user.tenant_id}:{dict_type.dict_type}" try: - dict_data_list = await DictDataCRUD(auth).get_obj_list_crud( + dict_data_list = await DictDataCRUD(auth).list( search={"dict_type": dict_type.dict_type} ) dict_data = [ @@ -591,13 +588,13 @@ class DictDataService: expire=None, ) except Exception as e: - log.error(f"更新字典数据类型变更时刷新旧缓存失败: {e}") + logger.error(f"更新字典数据类型变更时刷新旧缓存失败: {e}") - obj = await DictDataCRUD(auth).update_obj_crud(id=id, data=data) + obj = await DictDataCRUD(auth).update(id=id, data=data) redis_key = f"{RedisInitKeyConfig.SYSTEM_DICT.key}:{auth.user.tenant_id}:{data.dict_type}" try: # 获取当前字典类型的所有字典数据 - dict_data_list = await DictDataCRUD(auth).get_obj_list_crud( + dict_data_list = await DictDataCRUD(auth).list( search={"dict_type": data.dict_type} ) dict_data = [ @@ -612,12 +609,12 @@ class DictDataService: value=value, expire=None, ) - log.info(f"更新字典数据写入缓存成功: {obj}") + logger.info(f"更新字典数据写入缓存成功: {obj}") except Exception as e: - log.error(f"更新字典数据写入缓存失败: {e}") + logger.error(f"更新字典数据写入缓存失败: {e}") raise CustomException(msg=f"更新字典数据失败 {e}") - return DictDataOutSchema.model_validate(obj).model_dump() + return DictDataOutSchema.model_validate(obj) @classmethod async def delete_obj_service(cls, auth: AuthSchema, redis: Redis, ids: list[int]) -> None: @@ -636,24 +633,22 @@ class DictDataService: if len(ids) < 1: raise CustomException(msg="删除失败，删除对象不能为空") - # 首先检查是否包含系统默认数据 - for id in ids: - exist_obj = await DictDataCRUD(auth).get_obj_by_id_crud(id=id) - if not exist_obj: - raise CustomException(msg=f"{id} 删除失败，该字典数据不存在") + # 批量查询所有待删除项 + existing = await DictDataCRUD(auth).list(search={"id": ("in", ids)}) + existing_map = {obj.id: obj for obj in existing} + for nid in ids: + if nid not in existing_map: + raise CustomException(msg=f"{nid} 删除失败，该字典数据不存在") + exist_obj = existing_map[nid] # 系统默认字典数据不允许删除 if exist_obj.is_default: - raise CustomException(msg=f"删除失败，ID为{id}的系统默认字典数据不允许删除") + raise CustomException(msg=f"删除失败，ID为{nid}的系统默认字典数据不允许删除") - # 获取所有需要清除的缓存键 - dict_types_to_clear = set() - for id in ids: - exist_obj = await DictDataCRUD(auth).get_obj_by_id_crud(id=id) - if exist_obj: - dict_types_to_clear.add(exist_obj.dict_type) + # 从批量查询结果中收集缓存键 + dict_types_to_clear = {obj.dict_type for obj in existing} # 执行删除操作 - await DictDataCRUD(auth).delete_obj_crud(ids=ids) + await DictDataCRUD(auth).delete(ids=ids) # 清除缓存 for dict_type in dict_types_to_clear: @@ -662,17 +657,17 @@ class DictDataService: f"{RedisInitKeyConfig.SYSTEM_DICT.key}:{auth.user.tenant_id}:{dict_type}" ) await RedisCURD(redis).delete(redis_key) - log.info(f"清除字典缓存成功: {dict_type}") + logger.info(f"清除字典缓存成功: {dict_type}") except Exception as e: - log.warning(f"清除字典缓存失败: {e}") + logger.warning(f"清除字典缓存失败: {e}") # 缓存清除失败不影响删除操作 - log.info(f"删除字典数据成功，ID列表: {ids}") + logger.info(f"删除字典数据成功，ID列表: {ids}") except CustomException: raise except Exception as e: - log.error(f"删除字典数据失败: {e!s}") + logger.error(f"删除字典数据失败: {e!s}") raise CustomException(msg=f"删除字典数据失败: {e!s}") @classmethod @@ -687,7 +682,7 @@ class DictDataService: 返回: - None """ - await DictDataCRUD(auth).set_obj_available_crud(ids=data.ids, status=data.status) + await DictDataCRUD(auth).set(ids=data.ids, status=data.status) @classmethod async def export_obj_service(cls, data_list: list[dict]) -> bytes: @@ -721,13 +716,8 @@ class DictDataService: data = data_list.copy() for item in data: # 处理状态 - item["status"] = "启用" if item.get("status") == "0" else "停用" + item["status"] = "启用" if item.get("status") == 0 else "停用" # 处理是否默认 item["is_default"] = "是" if item.get("is_default") else "否" - item["creator"] = ( - item.get("creator", {}).get("name", "未知") - if isinstance(item.get("creator"), dict) - else "未知" - ) return ExcelUtil.export_list2excel(list_data=data, mapping_dict=mapping_dict) diff --git a/backend/app/api/v1/module_system/log/__init__.py b/backend/app/api/v1/module_system/log/__init__.py new file mode 100644 index 00000000..00942db2 --- /dev/null +++ b/backend/app/api/v1/module_system/log/__init__.py @@ -0,0 +1,3 @@ +from .controller import LogRouter + +__all__ = ["LogRouter"] diff --git a/backend/app/api/v1/module_system/log/controller.py b/backend/app/api/v1/module_system/log/controller.py new file mode 100644 index 00000000..1d794fa0 --- /dev/null +++ b/backend/app/api/v1/module_system/log/controller.py @@ -0,0 +1,231 @@ +from typing import Annotated + +from fastapi import APIRouter, Body, Depends, Path +from fastapi.responses import JSONResponse + +from app.common.response import ResponseSchema, SuccessResponse +from app.core.base_params import PaginationQueryParam +from app.core.base_schema import AuthSchema, BatchDelete, PageResultSchema +from app.core.dependencies import AuthPermission, get_current_user +from app.core.router_class import OperationLogRoute + +from .schema import ( + LoginLogCreateSchema, + LoginLogDetailOutSchema, + LoginLogOutSchema, + LoginLogQueryParam, + OperationLogCreateSchema, + OperationLogDetailOutSchema, + OperationLogOutSchema, + OperationLogQueryParam, +) +from .service import LoginLogService, OperationLogService + +LogRouter = APIRouter(route_class=OperationLogRoute, prefix="/log", tags=["系统管理/日志管理"]) + + +@LogRouter.get( + "/login/detail/{id}", + summary="获取登录日志详情", + response_model=ResponseSchema[LoginLogDetailOutSchema], +) +async def get_obj_detail_controller( + id: Annotated[int, Path(description="登录日志ID")], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:login_log:query']))], +) -> JSONResponse: + """ + 获取登录日志详情 + + 参数: + - id (int): 登录日志 ID。 + - auth (AuthSchema): 认证信息模型。 + + 返回: + - JSONResponse: 包含登录日志详情的 JSON 响应。 + """ + result_dict = await LoginLogService.detail_service(id=id, auth=auth) + return SuccessResponse(data=result_dict, msg="获取登录日志详情成功") + + +@LogRouter.get( + "/login/list", + summary="查询登录日志列表", + response_model=ResponseSchema[PageResultSchema[LoginLogOutSchema]], +) +async def get_obj_list_controller( + page: Annotated[PaginationQueryParam, Depends()], + search: Annotated[LoginLogQueryParam, Depends()], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:login_log:query']))], +) -> JSONResponse: + """ + 查询登录日志列表 + + 参数: + - page (PaginationQueryParam): 分页查询参数。 + - search (LoginLogQueryParam): 查询筛选参数。 + - auth (AuthSchema): 认证信息模型。 + + 返回: + - JSONResponse: 包含分页登录日志列表的 JSON 响应。 + """ + result_dict = await LoginLogService.page_service( + auth=auth, + page_no=page.page_no, + page_size=page.page_size, + search=search, + order_by=page.order_by, + ) + return SuccessResponse(data=result_dict, msg="查询登录日志列表成功") + + +@LogRouter.post( + "/login/create", + summary="创建登录日志", + response_model=ResponseSchema[LoginLogDetailOutSchema], +) +async def create_obj_controller( + data: LoginLogCreateSchema, + auth: Annotated[AuthSchema, Depends(get_current_user)], +) -> JSONResponse: + """ + 创建登录日志 + + 参数: + - data (LoginLogCreateSchema): 登录日志创建参数。 + - auth (AuthSchema): 认证信息模型。 + + 返回: + - JSONResponse: 包含创建后的登录日志详情的 JSON 响应。 + """ + result_dict = await LoginLogService.create_service(auth=auth, data=data) + return SuccessResponse(data=result_dict, msg="创建登录日志成功") + + +@LogRouter.delete( + "/login/delete", + summary="删除登录日志", + response_model=ResponseSchema, +) +async def delete_obj_controller( + ids: Annotated[list[int], Body(description="ID列表")], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:login_log:delete']))], +) -> JSONResponse: + """ + 删除登录日志 + + 参数: + - ids (list[int]): 日志 ID 列表。 + - auth (AuthSchema): 认证信息模型。 + + 返回: + - JSONResponse: 删除结果。 + """ + await LoginLogService.delete_service(auth=auth, ids=ids) + return SuccessResponse(msg="删除登录日志成功") + + +@LogRouter.get( + "/operation/detail/{id}", + summary="获取操作日志详情", + response_model=ResponseSchema[OperationLogDetailOutSchema], + dependencies=[Depends(AuthPermission(['module_system:log:query']))], +) +async def detail( + *, + id: Annotated[int, Path(gt=0)], + auth: Annotated[AuthSchema, Depends(get_current_user)], +): + """ + 获取操作日志详情 + + 参数: + - id (int): 操作日志 ID。 + - auth (AuthSchema): 认证信息模型。 + + 返回: + - JSONResponse: 包含操作日志详情的 JSON 响应。 + """ + result_dict = await OperationLogService.detail_service(auth, id) + return SuccessResponse(data=result_dict, msg="获取操作日志详情成功") + + +@LogRouter.get( + "/operation/list", + summary="获取操作日志列表", + response_model=ResponseSchema[PageResultSchema[OperationLogOutSchema]], + dependencies=[Depends(AuthPermission(['module_system:log:query']))], +) +async def list( + *, + page: Annotated[PaginationQueryParam, Depends()], + search: Annotated[OperationLogQueryParam, Depends()], + auth: Annotated[AuthSchema, Depends(get_current_user)], +): + """ + 获取操作日志列表 + + 参数: + - page (PaginationQueryParam): 分页查询参数。 + - search (OperationLogQueryParam): 查询筛选参数。 + - auth (AuthSchema): 认证信息模型。 + + 返回: + - JSONResponse: 包含分页操作日志列表的 JSON 响应。 + """ + result_dict = await OperationLogService.page_service( + auth, + page.page_no, + page.page_size, + search.model_dump(exclude_none=True), + page.order_by, + ) + return SuccessResponse(data=result_dict, msg="查询操作日志列表成功") + + +@LogRouter.post( + "/operation/create", + summary="创建操作日志", + response_model=ResponseSchema[OperationLogDetailOutSchema], +) +async def create( + *, + data: OperationLogCreateSchema, + auth: Annotated[AuthSchema, Depends(get_current_user)], +): + """ + 创建操作日志 + + 参数: + - data (OperationLogCreateSchema): 操作日志创建参数。 + - auth (AuthSchema): 认证信息模型。 + + 返回: + - JSONResponse: 包含创建后的操作日志详情的 JSON 响应。 + """ + result_dict = await OperationLogService.create_service(auth, data) + return SuccessResponse(data=result_dict, msg="创建操作日志成功") + + +@LogRouter.delete( + "/operation/delete", + summary="删除操作日志", + response_model=ResponseSchema, + dependencies=[Depends(AuthPermission(['module_system:log:delete']))], +) +async def delete( + *, + data: BatchDelete, + auth: Annotated[AuthSchema, Depends(get_current_user)], +): + """ + 删除操作日志 + + 参数: + - data (BatchDelete): 批量删除参数（ID 列表）。 + - auth (AuthSchema): 认证信息模型。 + + 返回: + - JSONResponse: 删除结果。 + """ + await OperationLogService.delete_service(auth, data.ids) + return SuccessResponse(msg="删除操作日志成功") diff --git a/backend/app/api/v1/module_system/log/crud.py b/backend/app/api/v1/module_system/log/crud.py new file mode 100644 index 00000000..cf457545 --- /dev/null +++ b/backend/app/api/v1/module_system/log/crud.py @@ -0,0 +1,19 @@ +from app.core.base_crud import CRUDBase +from app.core.base_schema import AuthSchema + +from .model import LoginLogModel, OperationLogModel +from .schema import LoginLogCreateSchema + + +class LoginLogCRUD(CRUDBase[LoginLogModel, LoginLogCreateSchema, None]): + """登录日志数据层""" + + def __init__(self, auth: AuthSchema) -> None: + super().__init__(model=LoginLogModel, auth=auth) + + +class OperationLogCRUD(CRUDBase[OperationLogModel, None, None]): + """操作日志 CRUD""" + + def __init__(self, auth: AuthSchema): + super().__init__(OperationLogModel, auth) diff --git a/backend/app/api/v1/module_system/operationlog/model.py b/backend/app/api/v1/module_system/log/model.py similarity index 70% rename from backend/app/api/v1/module_system/operationlog/model.py rename to backend/app/api/v1/module_system/log/model.py index db430f6e..38e1bc52 100644 --- a/backend/app/api/v1/module_system/operationlog/model.py +++ b/backend/app/api/v1/module_system/log/model.py @@ -20,6 +20,23 @@ def get_log_text_column_type(): return Text +class LoginLogModel(ModelMixin, TenantMixin, UserMixin): + """ + 登录日志模型 + """ + + __tablename__: str = "sys_login_log" + __table_args__: dict[str, str] = {"comment": "登录日志表"} + + status: Mapped[int] = mapped_column(Integer, default=1, comment="登录状态(1成功 2失败)") + username: Mapped[str] = mapped_column(String(64), nullable=False, comment="用户名") + login_location: Mapped[str | None] = mapped_column(String(255), nullable=True, comment="登录位置") + login_ip: Mapped[str | None] = mapped_column(String(50), nullable=True, comment="登录IP地址") + request_os: Mapped[str | None] = mapped_column(String(64), nullable=True, comment="操作系统") + request_browser: Mapped[str | None] = mapped_column(String(64), nullable=True, comment="浏览器") + msg: Mapped[str | None] = mapped_column(String(255), nullable=True, comment="提示消息") + + class OperationLogModel(ModelMixin, TenantMixin, UserMixin): """ 操作日志模型 @@ -34,9 +51,6 @@ class OperationLogModel(ModelMixin, TenantMixin, UserMixin): request_payload: Mapped[str | None] = mapped_column( get_log_text_column_type(), comment="请求体" ) - request_ip: Mapped[str | None] = mapped_column(String(50), comment="请求IP地址") - request_os: Mapped[str | None] = mapped_column(String(64), nullable=True, comment="操作系统") - request_browser: Mapped[str | None] = mapped_column(String(64), nullable=True, comment="浏览器") response_code: Mapped[int] = mapped_column(Integer, comment="响应状态码") response_json: Mapped[str | None] = mapped_column( get_log_text_column_type(), nullable=True, comment="响应体" diff --git a/backend/app/api/v1/module_system/log/schema.py b/backend/app/api/v1/module_system/log/schema.py new file mode 100644 index 00000000..d0571d98 --- /dev/null +++ b/backend/app/api/v1/module_system/log/schema.py @@ -0,0 +1,115 @@ +from fastapi import Query +from pydantic import BaseModel, ConfigDict, Field, field_validator + +from app.common.enums import QueueEnum +from app.core.base_schema import BaseSchema, UserBySchema +from app.core.validator import DateTimeStr + +ALLOWED_REQUEST_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"] + + +class LoginLogCreateSchema(BaseModel): + """新增登录日志""" + + username: str = Field(..., min_length=1, max_length=64, description="用户名") + status: int = Field(default=1, ge=1, le=2, description="登录状态(1成功 2失败)") + login_ip: str | None = Field(default=None, max_length=50, description="登录IP地址") + login_location: str | None = Field(default=None, max_length=255, description="登录位置") + request_os: str | None = Field(default=None, max_length=64, description="操作系统") + request_browser: str | None = Field(default=None, max_length=64, description="浏览器") + msg: str | None = Field(default=None, max_length=255, description="提示消息") + + @field_validator("username") + @classmethod + def validate_username(cls, v: str) -> str: + v = v.strip() + if not v: + raise ValueError("用户名不能为空") + if len(v) > 64: + raise ValueError("用户名长度不能超过64个字符") + return v + + @field_validator("status") + @classmethod + def validate_status(cls, v: int) -> int: + if v not in [1, 2]: + raise ValueError("登录状态只能为1(成功)或2(失败)") + return v + + +class LoginLogOutSchema(LoginLogCreateSchema, BaseSchema, UserBySchema): + """登录日志响应""" + + model_config = ConfigDict(from_attributes=True) + + +class LoginLogDetailOutSchema(LoginLogOutSchema): + """登录日志详情响应""" + + +class LoginLogQueryParam: + """登录日志查询参数""" + + def __init__( + self, + status: int | None = Query(None, ge=1, le=2, description="登录状态(1成功 2失败)"), + username: str | None = Query(None, max_length=64, description="用户名"), + created_time: list[DateTimeStr] | None = Query( + None, + description="创建时间范围", + examples=["2025-01-01 00:00:00", "2025-12-31 23:59:59"], + ), + ) -> None: + if status: + self.status = (QueueEnum.eq.value, status) + if username: + self.username = (QueueEnum.like.value, username) + + if created_time and len(created_time) == 2: + self.created_time = (QueueEnum.between.value, (created_time[0], created_time[1])) + + +class OperationLogQueryParam(BaseModel): + request_path: str | None = Field(None, max_length=255, description="请求路径") + request_method: str | None = Field(None, description="请求方式") + username: str | None = Field(None, max_length=64, description="用户名") + + @field_validator("request_method") + @classmethod + def validate_request_method(cls, value: str | None) -> str | None: + if value and value.upper() not in ALLOWED_REQUEST_METHODS: + raise ValueError(f"请求方式必须是: {', '.join(ALLOWED_REQUEST_METHODS)}") + return value.upper() if value else None + + +class OperationLogOutSchema(BaseSchema): + model_config = ConfigDict(from_attributes=True) + + id: int + tenant_id: int + request_path: str + request_method: str + response_code: int + process_time: str | None = None + + +class OperationLogDetailOutSchema(OperationLogOutSchema): + request_payload: str | None = None + response_json: str | None = None + + +class OperationLogCreateSchema(BaseModel): + request_path: str = Field(..., min_length=1, max_length=255, description="请求路径") + request_method: str = Field(..., description="请求方式") + request_payload: str | None = Field(None, description="请求体") + response_code: int = Field(200, ge=100, le=599, description="响应状态码") + response_json: str | None = Field(None, description="响应体") + process_time: str | None = Field(None, max_length=20, description="处理时间") + + @field_validator("request_method") + @classmethod + def validate_request_method(cls, value: str) -> str: + upper_value = value.upper() + if upper_value not in ALLOWED_REQUEST_METHODS: + raise ValueError(f"请求方式必须是: {', '.join(ALLOWED_REQUEST_METHODS)}") + return upper_value diff --git a/backend/app/api/v1/module_system/log/service.py b/backend/app/api/v1/module_system/log/service.py new file mode 100644 index 00000000..729faae9 --- /dev/null +++ b/backend/app/api/v1/module_system/log/service.py @@ -0,0 +1,172 @@ +from app.core.base_schema import AuthSchema +from app.core.exceptions import CustomException +from app.core.logger import logger + +from .crud import LoginLogCRUD, OperationLogCRUD +from .schema import ( + LoginLogCreateSchema, + LoginLogDetailOutSchema, + LoginLogOutSchema, + LoginLogQueryParam, + OperationLogCreateSchema, + OperationLogDetailOutSchema, + OperationLogOutSchema, +) + + +class LoginLogService: + """登录日志管理模块服务层""" + + @classmethod + async def detail_service(cls, auth: AuthSchema, id: int) -> LoginLogDetailOutSchema: + obj = await LoginLogCRUD(auth).get(id=id) + if not obj: + raise CustomException(msg="该数据不存在") + return LoginLogDetailOutSchema.model_validate(obj) + + @classmethod + async def page_service( + cls, + auth: AuthSchema, + page_no: int, + page_size: int, + search: LoginLogQueryParam | None = None, + order_by: list[dict[str, str]] | None = None, + ) -> dict: + search_dict = search.__dict__ if search else {} + order_by_list = order_by or [{"updated_time": "desc"}] + offset = (page_no - 1) * page_size + + result = await LoginLogCRUD(auth).page( + offset=offset, + limit=page_size, + order_by=order_by_list, + search=search_dict, + out_schema=LoginLogOutSchema, + ) + return result + + @classmethod + async def create_service(cls, auth: AuthSchema, data: LoginLogCreateSchema) -> LoginLogDetailOutSchema: + obj = await LoginLogCRUD(auth).create(data=data) + if not obj: + raise CustomException(msg="创建登录日志失败") + return LoginLogDetailOutSchema.model_validate(obj) + + @classmethod + async def delete_service(cls, auth: AuthSchema, ids: list[int]) -> None: + if len(ids) < 1: + raise CustomException(msg="删除失败，删除对象不能为空") + + existing = await LoginLogCRUD(auth).list(search={"id": ("in", ids)}) + existing_map = {obj.id for obj in existing} + for nid in ids: + if nid not in existing_map: + raise CustomException(msg=f"删除失败，ID为{nid}的数据不存在") + + await LoginLogCRUD(auth).delete(ids=ids) + + +class OperationLogService: + + @staticmethod + async def cleanup_operation_log() -> None: + """定时任务：清理超过保留期的操作日志和登录日志（PRD §14.5） + + 清理 create_time < now - retention_days 的记录。 + 保留期从全局参数 `operation_log_retention_days` 读取，默认 90 天。 + """ + from datetime import datetime, timedelta + + from sqlalchemy import delete + + from app.core.database import async_db_session + + from .model import LoginLogModel, OperationLogModel + + retention_days = 90 # 默认 90 天，可通过系统参数覆盖 + # 尝试从系统参数读取自定义保留期 + try: + from app.api.v1.module_system.params.model import ParamsModel + async with async_db_session() as _s: + from sqlalchemy import select + result = await _s.execute( + select(ParamsModel.config_value).where( + ParamsModel.config_key == "operation_log_retention_days" + ).limit(1) + ) + row = result.scalar() + if row is not None: + retention_days = int(row) + except Exception: + pass # 读取失败使用默认值 + + cutoff = datetime.now() - timedelta(days=retention_days) + async with async_db_session() as session: + op_stmt = delete(OperationLogModel).where(OperationLogModel.created_time < cutoff) + op_result = await session.execute(op_stmt) + + login_stmt = delete(LoginLogModel).where(LoginLogModel.created_time < cutoff) + login_result = await session.execute(login_stmt) + + await session.commit() + logger.info( + f"操作日志清理完成: " + f"操作日志 {op_result.rowcount} 条, " + f"登录日志 {login_result.rowcount} 条" + ) + return True + + @staticmethod + async def create_service(auth: AuthSchema, data: OperationLogCreateSchema) -> OperationLogDetailOutSchema: + crud = OperationLogCRUD(auth) + obj = await crud.create(data) + if not obj: + raise CustomException(msg="创建操作日志失败") + return OperationLogDetailOutSchema.model_validate(obj) + + @staticmethod + async def page_service( + auth: AuthSchema, + page: int, + page_size: int, + search: dict | None = None, + order_by: list[dict[str, str]] | None = None, + ) -> dict: + from app.common.enums import QueueEnum + + crud = OperationLogCRUD(auth) + + # 构建过滤条件 + filters = {} + if search: + if search.get("request_path"): + filters["request_path"] = (QueueEnum.like.value, search["request_path"]) + if search.get("request_method"): + filters["request_method"] = (QueueEnum.eq.value, search["request_method"]) + if search.get("username"): + filters["username"] = (QueueEnum.like.value, search["username"]) + + result = await crud.page( + offset=(page - 1) * page_size, + limit=page_size, + order_by=order_by or [{"id": "desc"}], + search=filters, + out_schema=OperationLogOutSchema, + ) + return result + + @staticmethod + async def detail_service(auth: AuthSchema, id: int) -> OperationLogDetailOutSchema: + crud = OperationLogCRUD(auth) + obj = await crud.get(id=id) + if not obj: + raise CustomException(msg="该操作日志不存在") + return OperationLogDetailOutSchema.model_validate(obj) + + @staticmethod + async def delete_service(auth: AuthSchema, ids: list[int]) -> None: + if len(ids) < 1: + raise CustomException(msg="删除失败，删除对象不能为空") + crud = OperationLogCRUD(auth) + await crud.delete(ids) diff --git a/backend/app/api/v1/module_system/menu/__init__.py b/backend/app/api/v1/module_system/menu/__init__.py deleted file mode 100644 index 8b137891..00000000 --- a/backend/app/api/v1/module_system/menu/__init__.py +++ /dev/null @@ -1 +0,0 @@ - diff --git a/backend/app/api/v1/module_system/menu/crud.py b/backend/app/api/v1/module_system/menu/crud.py deleted file mode 100644 index 5e150263..00000000 --- a/backend/app/api/v1/module_system/menu/crud.py +++ /dev/null @@ -1,96 +0,0 @@ -from collections.abc import Sequence - -from app.api.v1.module_system.auth.schema import AuthSchema -from app.core.base_crud import CRUDBase - -from .model import MenuModel -from .schema import MenuCreateSchema, MenuUpdateSchema - - -class MenuCRUD(CRUDBase[MenuModel, MenuCreateSchema, MenuUpdateSchema]): - """菜单模块数据层""" - - def __init__(self, auth: AuthSchema) -> None: - """ - 初始化菜单数据层。 - - 参数: - - auth (AuthSchema): 认证信息模型（含 DB 会话等上下文）。 - - 返回: - - None - """ - self.auth = auth - super().__init__(model=MenuModel, auth=auth) - - async def get_by_id_crud(self, id: int, preload: list[str] | None = None) -> MenuModel | None: - """ - 根据 id 获取菜单信息。 - - 参数: - - id (int): 菜单 ID。 - - preload (list[str] | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - MenuModel | None: 菜单信息，未找到返回 None。 - """ - obj = await self.get(id=id, preload=preload) - if not obj: - return None - return obj - - async def get_list_crud( - self, - search: dict | None = None, - order_by: list[dict] | None = None, - preload: list[str] | None = None, - ) -> Sequence[MenuModel]: - """ - 获取菜单列表。 - - 参数: - - search (dict | None): 搜索条件。 - - order_by (list[dict] | None): 排序字段列表。 - - preload (list[str] | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - Sequence[MenuModel]: 菜单列表。 - """ - return await self.list(search=search, order_by=order_by, preload=preload) - - async def get_tree_list_crud( - self, - search: dict | None = None, - order_by: list[dict] | None = None, - preload: list[str] | None = None, - ) -> Sequence[MenuModel]: - """ - 获取菜单树形列表。 - - 参数: - - search (dict | None): 搜索条件。 - - order_by (list[dict] | None): 排序字段列表。 - - preload (list[str] | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - Sequence[MenuModel]: 菜单树形列表。 - """ - return await self.tree_list( - search=search, - order_by=order_by, - children_attr="children", - preload=preload, - ) - - async def set_available_crud(self, ids: list[int], status: str) -> None: - """ - 批量设置菜单可用状态。 - - 参数: - - ids (list[int]): 菜单 ID 列表。 - - status (str): 可用状态。 - - 返回: - - None - """ - await self.set(ids=ids, status=status) diff --git a/backend/app/api/v1/module_system/notice/controller.py b/backend/app/api/v1/module_system/notice/controller.py index 2cbe57c3..63bc78f9 100644 --- a/backend/app/api/v1/module_system/notice/controller.py +++ b/backend/app/api/v1/module_system/notice/controller.py @@ -2,31 +2,39 @@ from typing import Annotated from fastapi import APIRouter, Body, Depends, Path from fastapi.responses import JSONResponse, StreamingResponse +from fastapi_cache import FastAPICache +from fastapi_cache.decorator import cache -from app.api.v1.module_system.auth.schema import AuthSchema from app.common.response import ResponseSchema, StreamResponse, SuccessResponse from app.core.base_params import PaginationQueryParam -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable, PageResultSchema from app.core.dependencies import AuthPermission, get_current_user -from app.core.logger import log +from app.core.logger import logger from app.core.router_class import OperationLogRoute from app.utils.common_util import bytes2file_response -from .schema import NoticeCreateSchema, NoticeOutSchema, NoticeQueryParam, NoticeUpdateSchema +from .schema import ( + NoticeCreateSchema, + NoticeOutSchema, + NoticeQueryParam, + NoticeUpdateSchema, + PanelDataOut, +) from .service import NoticeService -NoticeRouter = APIRouter(route_class=OperationLogRoute, prefix="/notice", tags=["公告通知"]) +NoticeRouter = APIRouter(route_class=OperationLogRoute, prefix="/notice", tags=["系统管理/公告通知"]) + +_NOTICE_NS = "notice" @NoticeRouter.get( "/detail/{id}", summary="获取公告详情", - description="获取公告详情", response_model=ResponseSchema[NoticeOutSchema], ) async def get_obj_detail_controller( id: Annotated[int, Path(description="公告ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:notice:detail"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:notice:detail']))], ) -> JSONResponse: """ 获取公告详情。 @@ -39,20 +47,18 @@ async def get_obj_detail_controller( - JSONResponse: 包含公告详情的响应模型。 """ result_dict = await NoticeService.get_notice_detail_service(id=id, auth=auth) - log.info(f"获取公告详情成功 {id}") return SuccessResponse(data=result_dict, msg="获取公告详情成功") @NoticeRouter.get( "/list", summary="查询公告", - description="查询公告", - response_model=ResponseSchema[list[NoticeOutSchema]], + response_model=ResponseSchema[PageResultSchema[NoticeOutSchema]], ) async def get_obj_list_controller( page: Annotated[PaginationQueryParam, Depends()], search: Annotated[NoticeQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:notice:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:notice:query']))], ) -> JSONResponse: """ 查询公告。 @@ -72,19 +78,17 @@ async def get_obj_list_controller( search=search, order_by=page.order_by, ) - log.info("查询公告列表成功") return SuccessResponse(data=result_dict, msg="查询公告列表成功") @NoticeRouter.post( "/create", summary="创建公告", - description="创建公告", response_model=ResponseSchema[NoticeOutSchema], ) async def create_obj_controller( data: NoticeCreateSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:notice:create"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:notice:create']))], ) -> JSONResponse: """ 创建公告。 @@ -97,20 +101,19 @@ async def create_obj_controller( - JSONResponse: 包含创建公告结果的响应模型。 """ result_dict = await NoticeService.create_notice_service(auth=auth, data=data) - log.info(f"创建公告成功: {result_dict}") + await FastAPICache.clear(namespace=_NOTICE_NS) return SuccessResponse(data=result_dict, msg="创建公告成功") @NoticeRouter.put( "/update/{id}", summary="修改公告", - description="修改公告", response_model=ResponseSchema[NoticeOutSchema], ) async def update_obj_controller( data: NoticeUpdateSchema, id: Annotated[int, Path(description="公告ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:notice:update"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:notice:update']))], ) -> JSONResponse: """ 修改公告。 @@ -124,19 +127,18 @@ async def update_obj_controller( - JSONResponse: 包含修改公告结果的响应模型。 """ result_dict = await NoticeService.update_notice_service(auth=auth, id=id, data=data) - log.info(f"修改公告成功: {result_dict}") + await FastAPICache.clear(namespace=_NOTICE_NS) return SuccessResponse(data=result_dict, msg="修改公告成功") @NoticeRouter.delete( "/delete", summary="删除公告", - description="删除公告", response_model=ResponseSchema[None], ) async def delete_obj_controller( ids: Annotated[list[int], Body(description="ID列表")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:notice:delete"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:notice:delete']))], ) -> JSONResponse: """ 删除公告。 @@ -149,19 +151,18 @@ async def delete_obj_controller( - JSONResponse: 包含删除公告结果的响应模型。 """ await NoticeService.delete_notice_service(auth=auth, ids=ids) - log.info(f"删除公告成功: {ids}") + await FastAPICache.clear(namespace=_NOTICE_NS) return SuccessResponse(msg="删除公告成功") @NoticeRouter.patch( "/status/batch", summary="批量修改公告状态", - description="批量修改公告状态", response_model=ResponseSchema[None], ) async def batch_set_available_obj_controller( data: BatchSetAvailable, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:notice:patch"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:notice:patch']))], ) -> JSONResponse: """ 批量修改公告状态。 @@ -174,19 +175,18 @@ async def batch_set_available_obj_controller( - JSONResponse: 包含批量修改公告状态结果的响应模型。 """ await NoticeService.set_notice_available_service(auth=auth, data=data) - log.info(f"批量修改公告状态成功: {data.ids}") + await FastAPICache.clear(namespace=_NOTICE_NS) return SuccessResponse(msg="批量修改公告状态成功") @NoticeRouter.get( "/export", summary="导出公告", - description="导出公告列表", response_model=ResponseSchema[None], ) async def export_obj_list_controller( search: Annotated[NoticeQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:notice:export"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:notice:export']))], ) -> StreamingResponse: """ 导出公告。 @@ -199,8 +199,8 @@ async def export_obj_list_controller( - StreamingResponse: 包含导出公告的流式响应模型。 """ result_dict_list = await NoticeService.get_notice_list_service(search=search, auth=auth) - export_result = await NoticeService.export_notice_service(notice_list=result_dict_list) - log.info("导出公告成功") + export_data = [item.model_dump() for item in result_dict_list] + export_result = await NoticeService.export_notice_service(notice_list=export_data) return StreamResponse( data=bytes2file_response(export_result), @@ -212,9 +212,9 @@ async def export_obj_list_controller( @NoticeRouter.get( "/available", summary="获取全局启用公告", - description="获取全局启用公告", response_model=ResponseSchema[list[NoticeOutSchema]], ) +@cache(expire=120, namespace=_NOTICE_NS) async def get_obj_list_available_controller( auth: Annotated[AuthSchema, Depends(get_current_user)], ) -> JSONResponse: @@ -228,18 +228,65 @@ async def get_obj_list_available_controller( - JSONResponse: 包含分页已启用公告详情的响应模型。 """ result_dict = await NoticeService.get_notice_available_page_service(auth=auth) - log.info("查询已启用公告列表成功") return SuccessResponse(data=result_dict, msg="查询已启用公告列表成功") @NoticeRouter.get( "/panel", summary="通知面板数据（铃铛）", - description="返回通知铃铛所需的全部数据：通知、消息、待办", + response_model=ResponseSchema[PanelDataOut], ) +@cache(expire=30, namespace=_NOTICE_NS) async def get_notification_panel_controller( auth: Annotated[AuthSchema, Depends(get_current_user)], ) -> JSONResponse: """通知面板聚合接口，返回通知、消息、待办三个列表。""" result = await NoticeService.get_panel_data_service(auth=auth) return SuccessResponse(data=result, msg="获取面板数据成功") + +# ============ 已读追踪端点 ============ + + +@NoticeRouter.post( + "/read/{id}", + summary="标记已读", + response_model=ResponseSchema[None], +) +async def mark_read_controller( + id: Annotated[int, Path(description="通知ID")], + auth: Annotated[AuthSchema, Depends(get_current_user)], +) -> JSONResponse: + """标记已读。通过 `sys_notice_read` 表记录已读时间。""" + await NoticeService.mark_read_service(auth=auth, notice_id=id) + await FastAPICache.clear(namespace=_NOTICE_NS) + logger.info(f"用户[{auth.user.id}]标记通知[{id}]已读") + return SuccessResponse(msg="标记已读成功") + + +@NoticeRouter.post( + "/read-all", + summary="全部已读", + response_model=ResponseSchema[int], +) +async def mark_all_read_controller( + auth: Annotated[AuthSchema, Depends(get_current_user)], +) -> JSONResponse: + """全部标记已读。返回本次操作标记的数量。""" + count = await NoticeService.mark_all_read_service(auth=auth) + await FastAPICache.clear(namespace=_NOTICE_NS) + logger.info(f"用户[{auth.user.id}]全部已读, 数量={count}") + return SuccessResponse(data=count, msg=f"全部标记已读成功，共标记 {count} 条") + + +@NoticeRouter.get( + "/unread-count", + summary="获取未读数量", + response_model=ResponseSchema[int], +) +@cache(expire=15, namespace=_NOTICE_NS) +async def get_unread_count_controller( + auth: Annotated[AuthSchema, Depends(get_current_user)], +) -> JSONResponse: + """获取未读通知数量。通过 LEFT JOIN 统计未读数。""" + count = await NoticeService.get_unread_count_service(auth=auth) + return SuccessResponse(data=count, msg="获取未读数量成功") diff --git a/backend/app/api/v1/module_system/notice/crud.py b/backend/app/api/v1/module_system/notice/crud.py index 536cf3bf..24671771 100644 --- a/backend/app/api/v1/module_system/notice/crud.py +++ b/backend/app/api/v1/module_system/notice/crud.py @@ -1,7 +1,5 @@ -from collections.abc import Sequence - -from app.api.v1.module_system.auth.schema import AuthSchema from app.core.base_crud import CRUDBase +from app.core.base_schema import AuthSchema from .model import NoticeModel from .schema import NoticeCreateSchema, NoticeUpdateSchema @@ -20,87 +18,4 @@ class NoticeCRUD(CRUDBase[NoticeModel, NoticeCreateSchema, NoticeUpdateSchema]): 返回: - None """ - self.auth = auth super().__init__(model=NoticeModel, auth=auth) - - async def get_by_id_crud(self, id: int, preload: list | None = None) -> NoticeModel | None: - """ - 根据ID获取公告详情。 - - 参数: - - id (int): 公告ID。 - - preload (list | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - NoticeModel | None: 公告模型实例。 - """ - return await self.get(id=id, preload=preload) - - async def get_list_crud( - self, - search: dict | None = None, - order_by: list[dict] | None = None, - preload: list | None = None, - ) -> Sequence[NoticeModel]: - """ - 获取公告列表。 - - 参数: - - search (dict | None): 查询参数。 - - order_by (list[dict] | None): 排序参数。 - - preload (list | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - Sequence[NoticeModel]: 公告模型实例列表。 - """ - return await self.list(search=search, order_by=order_by, preload=preload) - - async def create_crud(self, data: NoticeCreateSchema) -> NoticeModel | None: - """ - 创建公告。 - - 参数: - - data (NoticeCreateSchema): 公告创建模型。 - - 返回: - - NoticeModel | None: 公告模型实例。 - """ - return await self.create(data=data) - - async def update_crud(self, id: int, data: NoticeUpdateSchema) -> NoticeModel | None: - """ - 更新公告。 - - 参数: - - id (int): 公告ID。 - - data (NoticeUpdateSchema): 公告更新模型。 - - 返回: - - NoticeModel | None: 公告模型实例。 - """ - return await self.update(id=id, data=data) - - async def delete_crud(self, ids: list[int]) -> None: - """ - 删除公告。 - - 参数: - - ids (list[int]): 公告ID列表。 - - 返回: - - None - """ - return await self.delete(ids=ids) - - async def set_available_crud(self, ids: list[int], status: str) -> None: - """ - 设置公告的可用状态。 - - 参数: - - ids (list[int]): 公告ID列表。 - - status (str): 可用状态。 - - 返回: - - None - """ - return await self.set(ids=ids, status=status) diff --git a/backend/app/api/v1/module_system/notice/model.py b/backend/app/api/v1/module_system/notice/model.py index 672e7fe2..ac3ae425 100644 --- a/backend/app/api/v1/module_system/notice/model.py +++ b/backend/app/api/v1/module_system/notice/model.py @@ -1,7 +1,9 @@ -from sqlalchemy import String, Text -from sqlalchemy.orm import Mapped, mapped_column +from datetime import datetime -from app.core.base_model import ModelMixin, TenantMixin, UserMixin +from sqlalchemy import DateTime, ForeignKey, Integer, String, Text, UniqueConstraint +from sqlalchemy.orm import Mapped, mapped_column, relationship + +from app.core.base_model import MappedBase, ModelMixin, TenantMixin, UserMixin class NoticeModel(ModelMixin, TenantMixin, UserMixin): @@ -18,3 +20,35 @@ class NoticeModel(ModelMixin, TenantMixin, UserMixin): String(1), nullable=False, comment="公告类型(1通知 2公告)" ) notice_content: Mapped[str | None] = mapped_column(Text, nullable=True, comment="公告内容") + + +class NoticeReadModel(MappedBase): + """ + 通知已读记录表 — 记录用户对公告的已读状态。 + + 设计说明: + - 不继承 TenantMixin：该表按 user_id 隔离，租户上下文由所属 notice 间接确定 + - (user_id, notice_id) 唯一约束 — 未建立记录即代表未读 + - 仅用于标记已读时间，不做其他业务用途 + - 不继承 ModelMixin：使用 (user_id, notice_id) 复合主键，无需自增 id 列 + （避免 SQLite 不支持复合主键列 autoincrement 的问题） + """ + + __tablename__: str = "sys_notice_read" + __table_args__: tuple = ( + UniqueConstraint("user_id", "notice_id", name="uq_user_notice_read"), + {"comment": "通知已读记录表"}, + ) + + user_id: Mapped[int] = mapped_column( + Integer, ForeignKey("sys_user.id", ondelete="CASCADE"), primary_key=True, comment="用户ID" + ) + notice_id: Mapped[int] = mapped_column( + Integer, ForeignKey("sys_notice.id", ondelete="CASCADE"), primary_key=True, comment="通知ID" + ) + read_time: Mapped[datetime] = mapped_column( + DateTime, nullable=False, default=datetime.now, comment="已读时间" + ) + + # 关联 + notice: Mapped[NoticeModel] = relationship("NoticeModel", lazy="selectin") diff --git a/backend/app/api/v1/module_system/notice/schema.py b/backend/app/api/v1/module_system/notice/schema.py index 7ef0ba67..f447735e 100644 --- a/backend/app/api/v1/module_system/notice/schema.py +++ b/backend/app/api/v1/module_system/notice/schema.py @@ -18,8 +18,8 @@ class NoticeCreateSchema(BaseModel): notice_title: str = Field(..., min_length=1, max_length=64, description="公告标题") notice_type: str = Field(..., max_length=1, description="公告类型(1:通知 2:公告)") - notice_content: str = Field(..., max_length=65535, description="公告内容") - status: str = Field(default="0", max_length=1, description="状态(0:正常 1:禁用)") + notice_content: str | None = Field(default=None, max_length=65535, description="公告内容") + status: int = Field(default=0, ge=0, le=1, description="状态(0:正常 1:禁用)") description: str | None = Field(default=None, max_length=255, description="描述") @field_validator("notice_type") @@ -31,21 +31,23 @@ class NoticeCreateSchema(BaseModel): @field_validator("status") @classmethod - def _validate_status(cls, value: str): - if value not in {"0", "1"}: + def _validate_status(cls, value: int): + if value not in {0, 1}: raise ValueError("状态仅支持 0(正常) 或 1(禁用)") return value @field_validator("notice_content") @classmethod - def _sanitize_notice_content(cls, value: str) -> str: + def _sanitize_notice_content(cls, value: str | None) -> str | None: + if value is None: + return value return sanitize_html(value) @model_validator(mode="after") def _validate_after(self): if not self.notice_title.strip(): raise ValueError("公告标题不能为空") - if not self.notice_content.strip(): + if self.notice_content and not self.notice_content.strip(): raise ValueError("公告内容不能为空") return self @@ -85,7 +87,7 @@ class NoticeQueryParam: # 模糊查询字段 self.notice_title = (QueueEnum.like.value, notice_title) # 精确查询字段 - self.notice_type = notice_type + self.notice_type = (QueueEnum.eq.value, notice_type) # 模糊查询字段 if description: self.description = (QueueEnum.like.value, description) @@ -105,3 +107,22 @@ class NoticeQueryParam: self.created_id = (QueueEnum.eq.value, created_id) if updated_id: self.updated_id = (QueueEnum.eq.value, updated_id) + + +# ─── 通知面板 ─── + + +class PanelMessageItem(BaseModel): + """面板-消息项""" + id: int + title: str + content: str + time: str + type: str + + +class PanelDataOut(BaseModel): + """通知面板聚合数据""" + notices: list[NoticeOutSchema] = [] + messages: list[PanelMessageItem] = [] + pendings: list[dict] = [] diff --git a/backend/app/api/v1/module_system/notice/service.py b/backend/app/api/v1/module_system/notice/service.py index 2d65a17b..54b5544a 100644 --- a/backend/app/api/v1/module_system/notice/service.py +++ b/backend/app/api/v1/module_system/notice/service.py @@ -1,15 +1,17 @@ -from app.api.v1.module_system.auth.schema import AuthSchema -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable from app.core.exceptions import CustomException -from app.core.logger import log +from app.core.logger import logger from app.utils.excel_util import ExcelUtil from .crud import NoticeCRUD +from .model import NoticeModel, NoticeReadModel from .schema import ( NoticeCreateSchema, NoticeOutSchema, NoticeQueryParam, NoticeUpdateSchema, + PanelDataOut, + PanelMessageItem, ) @@ -19,7 +21,7 @@ class NoticeService: """ @classmethod - async def get_notice_detail_service(cls, auth: AuthSchema, id: int) -> dict: + async def get_notice_detail_service(cls, auth: AuthSchema, id: int) -> NoticeOutSchema: """ 获取公告详情。 @@ -30,25 +32,10 @@ class NoticeService: 返回: - Dict: 公告详情字典。 """ - notice_obj = await NoticeCRUD(auth).get_by_id_crud(id=id) - return NoticeOutSchema.model_validate(notice_obj).model_dump() - - @classmethod - async def get_notice_list_available_service(cls, auth: AuthSchema) -> list[dict]: - """ - 获取可用的公告列表。 - - 参数: - - auth (AuthSchema): 认证信息模型。 - - 返回: - - list[dict]: 可用公告详情字典列表。 - """ - notice_obj_list = await NoticeCRUD(auth).get_list_crud(search={"status": "0"}) - return [ - NoticeOutSchema.model_validate(notice_obj).model_dump() - for notice_obj in notice_obj_list - ] + notice_obj = await NoticeCRUD(auth).get(id=id) + if not notice_obj: + raise CustomException(msg="公告不存在") + return NoticeOutSchema.model_validate(notice_obj) @classmethod async def get_notice_list_service( @@ -56,7 +43,7 @@ class NoticeService: auth: AuthSchema, search: NoticeQueryParam | None = None, order_by: list[dict] | None = None, - ) -> list[dict]: + ) -> list[NoticeOutSchema]: """ 获取公告列表。 @@ -68,11 +55,11 @@ class NoticeService: 返回: - list[dict]: 公告详情字典列表。 """ - notice_obj_list = await NoticeCRUD(auth).get_list_crud( - search=search.__dict__, order_by=order_by + notice_obj_list = await NoticeCRUD(auth).list( + search=search.__dict__ if search else {}, order_by=order_by ) return [ - NoticeOutSchema.model_validate(notice_obj).model_dump() + NoticeOutSchema.model_validate(notice_obj) for notice_obj in notice_obj_list ] @@ -127,7 +114,7 @@ class NoticeService: ) @classmethod - async def create_notice_service(cls, auth: AuthSchema, data: NoticeCreateSchema) -> dict: + async def create_notice_service(cls, auth: AuthSchema, data: NoticeCreateSchema) -> NoticeOutSchema: """ 创建公告。 @@ -144,13 +131,13 @@ class NoticeService: notice = await NoticeCRUD(auth).get(notice_title=data.notice_title) if notice: raise CustomException(msg="创建失败，该公告通知已存在") - notice_obj = await NoticeCRUD(auth).create_crud(data=data) - return NoticeOutSchema.model_validate(notice_obj).model_dump() + notice_obj = await NoticeCRUD(auth).create(data=data) + return NoticeOutSchema.model_validate(notice_obj) @classmethod async def update_notice_service( cls, auth: AuthSchema, id: int, data: NoticeUpdateSchema - ) -> dict: + ) -> NoticeOutSchema: """ 更新公告。 @@ -165,14 +152,14 @@ class NoticeService: 异常: - CustomException: 更新失败，该公告通知不存在或公告通知标题重复。 """ - notice = await NoticeCRUD(auth).get_by_id_crud(id=id) + notice = await NoticeCRUD(auth).get(id=id) if not notice: raise CustomException(msg="更新失败，该公告通知不存在") exist_notice = await NoticeCRUD(auth).get(notice_title=data.notice_title) if exist_notice and exist_notice.id != id: raise CustomException(msg="更新失败，公告通知标题重复") - notice_obj = await NoticeCRUD(auth).update_crud(id=id, data=data) - return NoticeOutSchema.model_validate(notice_obj).model_dump() + notice_obj = await NoticeCRUD(auth).update(id=id, data=data) + return NoticeOutSchema.model_validate(notice_obj) @classmethod async def delete_notice_service(cls, auth: AuthSchema, ids: list[int]) -> None: @@ -191,11 +178,12 @@ class NoticeService: """ if len(ids) < 1: raise CustomException(msg="删除失败，删除对象不能为空") - for id in ids: - notice = await NoticeCRUD(auth).get_by_id_crud(id=id) - if not notice: + notices = await NoticeCRUD(auth).list(search={"id": ("in", ids)}) + notice_map = {n.id: n for n in notices} + for nid in ids: + if nid not in notice_map: raise CustomException(msg="删除失败，该公告通知不存在") - await NoticeCRUD(auth).delete_crud(ids=ids) + await NoticeCRUD(auth).delete(ids=ids) @classmethod async def set_notice_available_service(cls, auth: AuthSchema, data: BatchSetAvailable) -> None: @@ -212,7 +200,7 @@ class NoticeService: 返回: - None """ - await NoticeCRUD(auth).set_available_crud(ids=data.ids, status=data.status) + await NoticeCRUD(auth).set(ids=data.ids, status=data.status) @classmethod async def export_notice_service(cls, notice_list: list[dict]) -> bytes: @@ -242,19 +230,14 @@ class NoticeService: data = notice_list.copy() for item in data: # 处理状态 - item["status"] = "启用" if item.get("status") == "0" else "停用" + item["status"] = "启用" if item.get("status") == 0 else "停用" # 处理公告类型 item["notice_type"] = "通知" if item.get("notice_type") == "1" else "公告" - item["creator"] = ( - item.get("creator", {}).get("name", "未知") - if isinstance(item.get("creator"), dict) - else "未知" - ) return ExcelUtil.export_list2excel(list_data=data, mapping_dict=mapping_dict) @classmethod - async def get_latest_notices_service(cls, auth: AuthSchema, limit: int = 5) -> list[dict]: + async def get_latest_notices_service(cls, auth: AuthSchema, limit: int = 5) -> list[NoticeOutSchema]: """获取最新 N 条已启用公告""" from sqlalchemy import desc, select @@ -263,16 +246,101 @@ class NoticeService: stmt = ( select(NoticeModel) - .where(NoticeModel.status == "0") + .where(NoticeModel.status == 0) .order_by(desc(NoticeModel.created_time)) .limit(limit) ) result = await auth.db.execute(stmt) notices = result.scalars().all() - return [NoticeOutSchema.model_validate(n).model_dump() for n in notices] + return [NoticeOutSchema.model_validate(n) for n in notices] + + # ============ 已读追踪 ============ @classmethod - async def get_panel_data_service(cls, auth: AuthSchema) -> dict: + async def mark_read_service(cls, auth: AuthSchema, notice_id: int) -> None: + """标记通知为已读（幂等：已读的不重复写入）""" + from datetime import datetime + + from sqlalchemy import select + + # 检查公告是否存在 + notice = await NoticeCRUD(auth).get(id=notice_id) + if not notice: + raise CustomException(msg="该公告不存在") + + # 检查是否已读 + exist_stmt = select(NoticeReadModel).where( + NoticeReadModel.user_id == auth.user.id, + NoticeReadModel.notice_id == notice_id, + ) + result = await auth.db.execute(exist_stmt) + if result.scalar_one_or_none(): + return # 已读，幂等返回 + + read_record = NoticeReadModel( + user_id=auth.user.id, + notice_id=notice_id, + read_time=datetime.now(), + ) + auth.db.add(read_record) + await auth.db.flush() + + @classmethod + async def mark_all_read_service(cls, auth: AuthSchema) -> int: + """全部标记已读：将当前租户所有 status=0 且未读的公告批量标记为已读，返回操作数量""" + from datetime import datetime + + from sqlalchemy import select + + # 查询所有已启用但未读的公告 + read_ids_stmt = select(NoticeReadModel.notice_id).where( + NoticeReadModel.user_id == auth.user.id + ) + read_ids_result = await auth.db.execute(read_ids_stmt) + read_ids = {row[0] for row in read_ids_result.fetchall()} + + notices_stmt = select(NoticeModel.id).where(NoticeModel.status == 0) + notices_result = await auth.db.execute(notices_stmt) + all_ids = {row[0] for row in notices_result.fetchall()} + + unread_ids = all_ids - read_ids + if not unread_ids: + return 0 + + now = datetime.now() + from sqlalchemy import insert + + if unread_ids: + await auth.db.execute( + insert(NoticeReadModel), + [{"user_id": auth.user.id, "notice_id": nid, "read_time": now} for nid in unread_ids], + ) + await auth.db.flush() + return len(unread_ids) + + @classmethod + async def get_unread_count_service(cls, auth: AuthSchema) -> int: + """获取当前用户未读通知数量""" + from sqlalchemy import func, select + + # 所有已启用公告总数 + total_stmt = select(func.count()).select_from(NoticeModel).where( + NoticeModel.status == 0 + ) + total_result = await auth.db.execute(total_stmt) + total_count = total_result.scalar() or 0 + + # 已读数量 + read_stmt = select(func.count()).select_from(NoticeReadModel).where( + NoticeReadModel.user_id == auth.user.id + ) + read_result = await auth.db.execute(read_stmt) + read_count = read_result.scalar() or 0 + + return max(0, total_count - read_count) + + @classmethod + async def get_panel_data_service(cls, auth: AuthSchema) -> PanelDataOut: """聚合通知面板数据：通知 + 消息 + 待办""" from sqlalchemy import desc, select @@ -282,29 +350,29 @@ class NoticeService: # 2. 消息：最近的操作日志（作为系统消息） messages = [] try: - from app.api.v1.module_system.operationlog.model import OperationLogModel + from app.api.v1.module_system.log.model import OperationLogModel stmt = select(OperationLogModel).order_by(desc(OperationLogModel.created_time)).limit(5) result = await auth.db.execute(stmt) logs = result.scalars().all() for log_entry in logs: - messages.append({ - "id": log_entry.id, - "title": log_entry.oper_param or "系统操作", - "content": f"{log_entry.oper_user_name or '系统'} 执行了 {log_entry.title or '操作'}", - "time": log_entry.created_time.strftime("%Y-%m-%d %H:%M") + messages.append(PanelMessageItem( + id=log_entry.id, + title=log_entry.request_path or "系统操作", + content=f"{log_entry.request_method} {log_entry.request_path}", + time=log_entry.created_time.strftime("%Y-%m-%d %H:%M") if log_entry.created_time else "", - "type": "system", - }) - except Exception: - log.warning("获取面板消息数据失败（操作日志表可能不存在），已跳过") + type="system", + )) + except Exception as e: + logger.warning(f"获取面板消息数据失败（操作日志表可能不存在），已跳过: {e}") # 3. 待办：暂无数据源，返回空列表 pendings: list[dict] = [] - return { - "notices": notices, - "messages": messages, - "pendings": pendings, - } + return PanelDataOut( + notices=notices, + messages=messages, + pendings=pendings, + ) diff --git a/backend/app/api/v1/module_system/operationlog/__init__.py b/backend/app/api/v1/module_system/operationlog/__init__.py deleted file mode 100644 index b475e6f7..00000000 --- a/backend/app/api/v1/module_system/operationlog/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from .controller import OperationLogRouter - -__all__ = ["OperationLogRouter"] diff --git a/backend/app/api/v1/module_system/operationlog/controller.py b/backend/app/api/v1/module_system/operationlog/controller.py deleted file mode 100644 index 14f175bc..00000000 --- a/backend/app/api/v1/module_system/operationlog/controller.py +++ /dev/null @@ -1,85 +0,0 @@ -from typing import Annotated - -from fastapi import APIRouter, Depends, Path - -from app.api.v1.module_system.auth.schema import AuthSchema -from app.common.response import ResponseSchema -from app.core.base_params import PaginationQueryParam -from app.core.base_schema import BatchDelete -from app.core.dependencies import AuthPermission, get_current_user - -from .schema import ( - OperationLogCreateSchema, - OperationLogDetailOutSchema, - OperationLogQueryParam, -) -from .service import OperationLogService - -OperationLogRouter = APIRouter(prefix="/operationlog", tags=["操作日志"]) - - -@OperationLogRouter.get( - "/detail/{id}", - summary="获取操作日志详情", - description="根据ID获取操作日志详情", - response_model=ResponseSchema[OperationLogDetailOutSchema], - dependencies=[Depends(AuthPermission("module_system:operation_log:query"))], -) -async def detail( - *, - id: Annotated[int, Path(gt=0)], - auth: AuthSchema = Depends(get_current_user), -): - return await OperationLogService.detail_service(auth, id) - - -@OperationLogRouter.get( - "/list", - summary="获取操作日志列表", - description="分页获取操作日志列表", - response_model=ResponseSchema[dict], - dependencies=[Depends(AuthPermission("module_system:operation_log:query"))], -) -async def list( - *, - page: Annotated[PaginationQueryParam, Depends()], - search: OperationLogQueryParam, - auth: AuthSchema = Depends(get_current_user), -): - return await OperationLogService.page_service( - auth, - page.page, - page.page_size, - search.to_dict(), - [{"id": page.order_by}], - ) - - -@OperationLogRouter.post( - "/create", - summary="创建操作日志", - description="创建操作日志（由系统自动调用）", - response_model=ResponseSchema[OperationLogDetailOutSchema], -) -async def create( - *, - data: OperationLogCreateSchema, - auth: AuthSchema = Depends(get_current_user), -): - return await OperationLogService.create_service(auth, data) - - -@OperationLogRouter.delete( - "/delete", - summary="删除操作日志", - description="批量删除操作日志", - response_model=ResponseSchema, - dependencies=[Depends(AuthPermission("module_system:operation_log:delete"))], -) -async def delete( - *, - data: BatchDelete, - auth: AuthSchema = Depends(get_current_user), -): - await OperationLogService.delete_service(auth, data.ids) - return ResponseSchema() diff --git a/backend/app/api/v1/module_system/operationlog/crud.py b/backend/app/api/v1/module_system/operationlog/crud.py deleted file mode 100644 index 496b144f..00000000 --- a/backend/app/api/v1/module_system/operationlog/crud.py +++ /dev/null @@ -1,11 +0,0 @@ -from app.api.v1.module_system.auth.schema import AuthSchema -from app.core.base_crud import CRUDBase - -from .model import OperationLogModel - - -class OperationLogCRUD(CRUDBase[OperationLogModel, None, None]): - """操作日志 CRUD""" - - def __init__(self, auth: AuthSchema): - super().__init__(OperationLogModel, auth) diff --git a/backend/app/api/v1/module_system/operationlog/schema.py b/backend/app/api/v1/module_system/operationlog/schema.py deleted file mode 100644 index d9d08b55..00000000 --- a/backend/app/api/v1/module_system/operationlog/schema.py +++ /dev/null @@ -1,63 +0,0 @@ -from datetime import datetime - -from pydantic import BaseModel, ConfigDict, Field, field_validator - -ALLOWED_REQUEST_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"] - - -class OperationLogQueryParam(BaseModel): - request_path: str | None = Field(None, max_length=255, description="请求路径") - request_method: str | None = Field(None, description="请求方式") - username: str | None = Field(None, max_length=64, description="用户名") - - @field_validator("request_method") - @classmethod - def validate_request_method(cls, value: str | None) -> str | None: - if value and value.upper() not in ALLOWED_REQUEST_METHODS: - raise ValueError(f"请求方式必须是: {', '.join(ALLOWED_REQUEST_METHODS)}") - return value.upper() if value else None - - def to_dict(self) -> dict | None: - """转换为字典，仅包含非空字段""" - return self.model_dump(exclude_none=True) - - -class OperationLogOutSchema(BaseModel): - model_config = ConfigDict(from_attributes=True) - - id: int - username: str - tenant_id: int - request_path: str - request_method: str - request_ip: str | None = None - request_os: str | None = None - request_browser: str | None = None - response_code: int - process_time: str | None = None - created_at: datetime - - -class OperationLogDetailOutSchema(OperationLogOutSchema): - request_payload: str | None = None - response_json: str | None = None - - -class OperationLogCreateSchema(BaseModel): - request_path: str = Field(..., min_length=1, max_length=255, description="请求路径") - request_method: str = Field(..., description="请求方式") - request_payload: str | None = Field(None, description="请求体") - request_ip: str | None = Field(None, max_length=50, description="请求IP地址") - request_os: str | None = Field(None, max_length=64, description="操作系统") - request_browser: str | None = Field(None, max_length=64, description="浏览器") - response_code: int = Field(200, ge=100, le=599, description="响应状态码") - response_json: str | None = Field(None, description="响应体") - process_time: str | None = Field(None, max_length=20, description="处理时间") - - @field_validator("request_method") - @classmethod - def validate_request_method(cls, value: str) -> str: - upper_value = value.upper() - if upper_value not in ALLOWED_REQUEST_METHODS: - raise ValueError(f"请求方式必须是: {', '.join(ALLOWED_REQUEST_METHODS)}") - return upper_value diff --git a/backend/app/api/v1/module_system/operationlog/service.py b/backend/app/api/v1/module_system/operationlog/service.py deleted file mode 100644 index 123880bd..00000000 --- a/backend/app/api/v1/module_system/operationlog/service.py +++ /dev/null @@ -1,59 +0,0 @@ -from sqlalchemy.ext.asyncio import AsyncSession - -from app.api.v1.module_system.auth.schema import AuthSchema -from app.api.v1.module_system.operationlog.crud import OperationLogCRUD -from app.api.v1.module_system.operationlog.schema import ( - OperationLogCreateSchema, - OperationLogDetailOutSchema, - OperationLogOutSchema, -) -from app.core.logger import log - - -class OperationLogService: - @staticmethod - async def create_service(auth: AuthSchema, data: OperationLogCreateSchema) -> OperationLogDetailOutSchema: - crud = OperationLogCRUD(auth) - obj = await crud.create(data.model_dump()) - return OperationLogDetailOutSchema.model_validate(obj) - - @staticmethod - async def page_service( - auth: AuthSchema, - page: int, - page_size: int, - search: dict | None = None, - order_by: list[dict[str, str]] | None = None, - ) -> dict: - crud = OperationLogCRUD(auth) - - # 构建过滤条件 - filters = {} - if search: - if search.get("request_path"): - filters["request_path"] = search["request_path"] - if search.get("request_method"): - filters["request_method"] = search["request_method"] - if search.get("username"): - filters["username"] = search["username"] - - result = await crud.page( - offset=(page - 1) * page_size, - limit=page_size, - order_by=order_by or [{"id": "desc"}], - search=filters, - out_schema=OperationLogOutSchema, - ) - return result - - @staticmethod - async def detail_service(auth: AuthSchema, id: int) -> OperationLogDetailOutSchema: - crud = OperationLogCRUD(auth) - obj = await crud.get(id=id) - return OperationLogDetailOutSchema.model_validate(obj) - - @staticmethod - async def delete_service(auth: AuthSchema, ids: list[int]) -> None: - crud = OperationLogCRUD(auth) - await crud.delete(ids) - log.info(f"删除操作日志成功, ids={ids}") diff --git a/backend/app/api/v1/module_system/params/controller.py b/backend/app/api/v1/module_system/params/controller.py index 1395ca4d..ca5bad0e 100644 --- a/backend/app/api/v1/module_system/params/controller.py +++ b/backend/app/api/v1/module_system/params/controller.py @@ -4,29 +4,27 @@ from fastapi import APIRouter, Body, Depends, Path from fastapi.responses import JSONResponse, StreamingResponse from redis.asyncio.client import Redis -from app.api.v1.module_system.auth.schema import AuthSchema from app.common.response import ResponseSchema, StreamResponse, SuccessResponse from app.core.base_params import PaginationQueryParam +from app.core.base_schema import AuthSchema, PageResultSchema from app.core.dependencies import AuthPermission, redis_getter -from app.core.logger import log from app.core.router_class import OperationLogRoute from app.utils.common_util import bytes2file_response from .schema import ParamsCreateSchema, ParamsOutSchema, ParamsQueryParam, ParamsUpdateSchema from .service import ParamsService -ParamsRouter = APIRouter(route_class=OperationLogRoute, prefix="/param", tags=["参数管理"]) +ParamsRouter = APIRouter(route_class=OperationLogRoute, prefix="/param", tags=["系统管理/参数管理"]) @ParamsRouter.get( "/detail/{id}", summary="获取参数详情", - description="获取参数详情", response_model=ResponseSchema[ParamsOutSchema], ) async def get_type_detail_controller( id: Annotated[int, Path(description="参数ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:param:detail"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:param:detail']))], ) -> JSONResponse: """ 获取参数详情 @@ -39,19 +37,17 @@ async def get_type_detail_controller( - JSONResponse: 包含参数详情的 JSON 响应 """ result_dict = await ParamsService.get_obj_detail_service(id=id, auth=auth) - log.info(f"获取参数详情成功 {id}") return SuccessResponse(data=result_dict, msg="获取参数详情成功") @ParamsRouter.get( "/key/{config_key}", summary="根据配置键获取参数详情", - description="根据配置键获取参数详情", response_model=ResponseSchema[ParamsOutSchema], ) async def get_obj_by_key_controller( config_key: Annotated[str, Path(description="配置键")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:param:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:param:query']))], ) -> JSONResponse: """ 根据配置键获取参数详情 @@ -64,19 +60,17 @@ async def get_obj_by_key_controller( - JSONResponse: 包含参数详情的 JSON 响应 """ result_dict = await ParamsService.get_obj_by_key_service(config_key=config_key, auth=auth) - log.info(f"根据配置键获取参数详情成功 {config_key}") return SuccessResponse(data=result_dict, msg="根据配置键获取参数详情成功") @ParamsRouter.get( "/value/{config_key}", summary="根据配置键获取参数值", - description="根据配置键获取参数值", response_model=ResponseSchema[ParamsOutSchema], ) async def get_config_value_by_key_controller( config_key: Annotated[str, Path(description="配置键")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:param:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:param:query']))], ) -> JSONResponse: """ 根据配置键获取参数值 @@ -91,18 +85,16 @@ async def get_config_value_by_key_controller( result_value = await ParamsService.get_config_value_by_key_service( config_key=config_key, auth=auth ) - log.info(f"根据配置键获取参数值成功 {config_key}") return SuccessResponse(data=result_value, msg="根据配置键获取参数值成功") @ParamsRouter.get( "/list", summary="获取参数列表", - description="获取参数列表", - response_model=ResponseSchema[list[ParamsOutSchema]], + response_model=ResponseSchema[PageResultSchema[ParamsOutSchema]], ) async def get_obj_list_controller( - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:param:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:param:query']))], page: Annotated[PaginationQueryParam, Depends()], search: Annotated[ParamsQueryParam, Depends()], ) -> JSONResponse: @@ -124,20 +116,18 @@ async def get_obj_list_controller( search=search, order_by=page.order_by, ) - log.info("获取参数列表成功") return SuccessResponse(data=result_dict, msg="查询参数列表成功") @ParamsRouter.post( "/create", summary="创建参数", - description="创建参数", response_model=ResponseSchema[ParamsOutSchema], ) async def create_obj_controller( data: ParamsCreateSchema, redis: Annotated[Redis, Depends(redis_getter)], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:param:create"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:param:create']))], ) -> JSONResponse: """ 创建参数 @@ -151,21 +141,19 @@ async def create_obj_controller( - JSONResponse: 包含创建参数结果的 JSON 响应 """ result_dict = await ParamsService.create_obj_service(auth=auth, redis=redis, data=data) - log.info(f"创建参数成功: {result_dict}") return SuccessResponse(data=result_dict, msg="创建参数成功") @ParamsRouter.put( "/update/{id}", summary="修改参数", - description="修改参数", response_model=ResponseSchema[ParamsOutSchema], ) async def update_objs_controller( data: ParamsUpdateSchema, id: Annotated[int, Path(description="参数ID")], redis: Annotated[Redis, Depends(redis_getter)], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:param:update"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:param:update']))], ) -> JSONResponse: """ 修改参数 @@ -180,20 +168,18 @@ async def update_objs_controller( - JSONResponse: 包含修改参数结果的 JSON 响应 """ result_dict = await ParamsService.update_obj_service(auth=auth, redis=redis, id=id, data=data) - log.info(f"更新参数成功 {result_dict}") return SuccessResponse(data=result_dict, msg="更新参数成功") @ParamsRouter.delete( "/delete", summary="删除参数", - description="删除参数", response_model=ResponseSchema[ParamsOutSchema], ) async def delete_obj_controller( redis: Annotated[Redis, Depends(redis_getter)], ids: Annotated[list[int], Body(description="ID列表")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:param:delete"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:param:delete']))], ) -> JSONResponse: """ 删除参数 @@ -207,20 +193,18 @@ async def delete_obj_controller( - JSONResponse: 包含删除参数结果的 JSON 响应 """ await ParamsService.delete_obj_service(auth=auth, redis=redis, ids=ids) - log.info(f"删除参数成功: {ids}") return SuccessResponse(msg="删除参数成功") @ParamsRouter.patch( "/status/batch", summary="批量设置参数状态", - description="批量设置参数状态", response_model=ResponseSchema, ) async def batch_set_status_controller( ids: Annotated[list[int], Body(description="参数ID列表")], status: Annotated[str, Body(description="状态值")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:param:patch"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:param:patch']))], ) -> JSONResponse: """ 批量设置参数状态 @@ -234,19 +218,17 @@ async def batch_set_status_controller( - JSONResponse: 包含批量设置参数状态结果的 JSON 响应 """ await ParamsService.batch_set_status_service(auth=auth, ids=ids, status=status) - log.info(f"批量设置参数状态成功: ids={ids}, status={status}") return SuccessResponse(msg="批量设置参数状态成功") @ParamsRouter.get( "/export", summary="导出参数", - description="导出参数列表", response_model=ResponseSchema[None], ) async def export_obj_list_controller( search: Annotated[ParamsQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:param:export"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:param:export']))], ) -> StreamingResponse: """ 导出参数 @@ -259,8 +241,8 @@ async def export_obj_list_controller( - StreamingResponse: 包含导出参数的 Excel 文件流响应 """ result_dict_list = await ParamsService.get_obj_list_service(search=search, auth=auth) - export_result = await ParamsService.export_obj_service(data_list=result_dict_list) - log.info("导出参数成功") + export_data = [item.model_dump() for item in result_dict_list] + export_result = await ParamsService.export_obj_service(data_list=export_data) return StreamResponse( data=bytes2file_response(export_result), @@ -272,7 +254,6 @@ async def export_obj_list_controller( @ParamsRouter.get( "/info", summary="获取初始化缓存参数", - description="获取初始化缓存参数", response_model=ResponseSchema[list[ParamsOutSchema]], ) async def get_init_obj_controller( @@ -288,5 +269,4 @@ async def get_init_obj_controller( - JSONResponse: 获取初始化缓存参数的 JSON 响应 """ result_dict = await ParamsService.get_init_config_service(redis=redis, tenant_id=1) - log.info(f"获取初始化缓存参数成功 {result_dict}") return SuccessResponse(data=result_dict, msg="获取初始化缓存参数成功") diff --git a/backend/app/api/v1/module_system/params/crud.py b/backend/app/api/v1/module_system/params/crud.py index 4ac1e947..4a38cad2 100644 --- a/backend/app/api/v1/module_system/params/crud.py +++ b/backend/app/api/v1/module_system/params/crud.py @@ -1,7 +1,5 @@ -from collections.abc import Sequence - -from app.api.v1.module_system.auth.schema import AuthSchema from app.core.base_crud import CRUDBase +from app.core.base_schema import AuthSchema from .model import ParamsModel from .schema import ParamsCreateSchema, ParamsUpdateSchema @@ -20,89 +18,4 @@ class ParamsCRUD(CRUDBase[ParamsModel, ParamsCreateSchema, ParamsUpdateSchema]): 返回: - None """ - self.auth = auth super().__init__(model=ParamsModel, auth=auth) - - async def get_obj_by_id_crud(self, id: int, preload: list | None = None) -> ParamsModel | None: - """ - 获取配置管理型详情 - - 参数: - - id (int): 配置管理型ID - - preload (list | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - ParamsModel | None: 配置管理型模型实例 - """ - return await self.get(id=id, preload=preload) - - async def get_obj_by_key_crud( - self, key: str, preload: list | None = None - ) -> ParamsModel | None: - """ - 根据key获取配置管理型详情 - - 参数: - - key (str): 配置管理型key - - preload (list | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - ParamsModel | None: 配置管理型模型实例 - """ - return await self.get(config_key=key, preload=preload) - - async def get_obj_list_crud( - self, - search: dict | None = None, - order_by: list | None = None, - preload: list | None = None, - ) -> Sequence[ParamsModel]: - """ - 获取配置管理型列表 - - 参数: - - search (dict | None): 查询参数对象。 - - order_by (list | None): 排序参数列表。 - - preload (list | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - Sequence[ParamsModel]: 配置管理型模型实例列表 - """ - return await self.list(search=search, order_by=order_by, preload=preload) - - async def create_obj_crud(self, data: ParamsCreateSchema) -> ParamsModel | None: - """ - 创建配置管理型 - - 参数: - - data (ParamsCreateSchema): 创建配置管理型负载模型 - - 返回: - - ParamsModel | None: 配置管理型模型实例 - """ - return await self.create(data=data) - - async def update_obj_crud(self, id: int, data: ParamsUpdateSchema) -> ParamsModel | None: - """ - 更新配置管理型 - - 参数: - - id (int): 配置管理型ID - - data (ParamsUpdateSchema): 更新配置管理型负载模型 - - 返回: - - ParamsModel | None: 配置管理型模型实例 - """ - return await self.update(id=id, data=data) - - async def delete_obj_crud(self, ids: list[int]) -> None: - """ - 删除配置管理型 - - 参数: - - ids (list[int]): 配置管理型ID列表 - - 返回: - - None - """ - return await self.delete(ids=ids) diff --git a/backend/app/api/v1/module_system/params/schema.py b/backend/app/api/v1/module_system/params/schema.py index 28cfa5b6..e6b4ab5b 100644 --- a/backend/app/api/v1/module_system/params/schema.py +++ b/backend/app/api/v1/module_system/params/schema.py @@ -13,7 +13,7 @@ class ParamsCreateSchema(BaseModel): config_key: str = Field(..., min_length=1, max_length=500, description="参数键名") config_value: str | None = Field(default=None, max_length=500, description="参数键值") config_type: bool = Field(default=False, description="是否系统内置") - status: str = Field(default="0", max_length=1, description="状态(0:正常 1:停用)") + status: int = Field(default=0, ge=0, le=1, description="状态(0:正常 1:停用)") description: str | None = Field(default=None, max_length=500, description="描述") @field_validator("config_key") @@ -27,8 +27,8 @@ class ParamsCreateSchema(BaseModel): @field_validator("status") @classmethod - def _validate_status(cls, v: str) -> str: - if v not in {"0", "1"}: + def _validate_status(cls, v: int) -> int: + if v not in {0, 1}: raise ValueError("状态仅支持 0(正常) 或 1(停用)") return v @@ -64,12 +64,11 @@ class ParamsQueryParam: examples=["2025-01-01 00:00:00", "2025-12-31 23:59:59"], ), ) -> None: - # 模糊查询字段 # 模糊查询字段 self.config_name = (QueueEnum.like.value, config_name) self.config_key = (QueueEnum.like.value, config_key) # 精确查询字段 - self.config_type = config_type + self.config_type = (QueueEnum.eq.value, config_type) if description: self.description = (QueueEnum.like.value, description) diff --git a/backend/app/api/v1/module_system/params/service.py b/backend/app/api/v1/module_system/params/service.py index 76a41716..74005b6c 100644 --- a/backend/app/api/v1/module_system/params/service.py +++ b/backend/app/api/v1/module_system/params/service.py @@ -1,12 +1,13 @@ import json +import time from redis.asyncio.client import Redis -from app.api.v1.module_system.auth.schema import AuthSchema from app.common.enums import RedisInitKeyConfig +from app.core.base_schema import AuthSchema from app.core.database import async_db_session from app.core.exceptions import CustomException -from app.core.logger import log +from app.core.logger import logger from app.core.redis_crud import RedisCURD from app.utils.excel_util import ExcelUtil @@ -18,6 +19,10 @@ from .schema import ( ParamsUpdateSchema, ) +# 中间件系统配置内存缓存（避免每请求查 Redis） +_MID_CONFIG_TTL: float = 60.0 # 缓存 60 秒 +_mid_config_cache: dict = {"ts": 0.0, "data": None} + class ParamsService: """ @@ -25,7 +30,7 @@ class ParamsService: """ @classmethod - async def get_obj_detail_service(cls, auth: AuthSchema, id: int) -> dict: + async def get_obj_detail_service(cls, auth: AuthSchema, id: int) -> ParamsOutSchema: """ 获取配置详情 @@ -36,11 +41,13 @@ class ParamsService: 返回: - dict: 配置管理型模型实例字典表示 """ - obj = await ParamsCRUD(auth).get_obj_by_id_crud(id=id) - return ParamsOutSchema.model_validate(obj).model_dump() + obj = await ParamsCRUD(auth).get(id=id) + if not obj: + raise CustomException(msg="参数不存在") + return ParamsOutSchema.model_validate(obj) @classmethod - async def get_obj_by_key_service(cls, auth: AuthSchema, config_key: str) -> dict: + async def get_obj_by_key_service(cls, auth: AuthSchema, config_key: str) -> ParamsOutSchema: """ 根据配置键获取配置详情 @@ -51,10 +58,10 @@ class ParamsService: 返回: - Dict: 配置管理型模型实例字典表示 """ - obj = await ParamsCRUD(auth).get_obj_by_key_crud(key=config_key) + obj = await ParamsCRUD(auth).get(config_key=config_key) if not obj: raise CustomException(msg=f"配置键 {config_key} 不存在") - return ParamsOutSchema.model_validate(obj).model_dump() + return ParamsOutSchema.model_validate(obj) @classmethod async def get_config_value_by_key_service(cls, auth: AuthSchema, config_key: str) -> str | None: @@ -68,7 +75,7 @@ class ParamsService: 返回: - str | None: 配置值字符串或None """ - obj = await ParamsCRUD(auth).get_obj_by_key_crud(key=config_key) + obj = await ParamsCRUD(auth).get(config_key=config_key) if not obj: raise CustomException(msg=f"配置键 {config_key} 不存在") return obj.config_value @@ -79,7 +86,7 @@ class ParamsService: auth: AuthSchema, search: ParamsQueryParam | None = None, order_by: list[dict] | None = None, - ) -> list[dict]: + ) -> list[ParamsOutSchema]: """ 获取配置管理型列表 @@ -89,16 +96,12 @@ class ParamsService: - order_by (list[dict] | None): 排序参数列表 返回: - - list[dict]: 配置管理型模型实例字典列表表示 + - list[ParamsOutSchema]: 配置管理型模型实例 """ - obj_list = None - if search: - obj_list = await ParamsCRUD(auth).get_obj_list_crud( - search=search.__dict__, order_by=order_by - ) - else: - obj_list = await ParamsCRUD(auth).get_obj_list_crud() - return [ParamsOutSchema.model_validate(obj).model_dump() for obj in obj_list] + obj_list = await ParamsCRUD(auth).list( + search=search.__dict__ if search else {}, order_by=order_by + ) + return [ParamsOutSchema.model_validate(obj) for obj in obj_list] @classmethod async def get_obj_page_service( @@ -134,7 +137,7 @@ class ParamsService: @classmethod async def create_obj_service( cls, auth: AuthSchema, redis: Redis, data: ParamsCreateSchema - ) -> dict: + ) -> ParamsOutSchema: """ 创建配置管理型 @@ -149,33 +152,35 @@ class ParamsService: exist_obj = await ParamsCRUD(auth).get(config_key=data.config_key) if exist_obj: raise CustomException(msg="创建失败，该配置key已存在") - obj = await ParamsCRUD(auth).create_obj_crud(data=data) + obj = await ParamsCRUD(auth).create(data=data) - new_obj_dict = ParamsOutSchema.model_validate(obj).model_dump() + out = ParamsOutSchema.model_validate(obj) # 同步redis redis_key = ( f"{RedisInitKeyConfig.SYSTEM_CONFIG.key}:{auth.user.tenant_id}:{data.config_key}" ) try: + redis_payload = out.model_dump(mode="json") + value = json.dumps(redis_payload, ensure_ascii=False) result = await RedisCURD(redis).set( key=redis_key, - value="", + value=value, expire=None, ) if not result: - log.error(f"同步配置到缓存失败: {new_obj_dict}") + logger.error(f"同步配置到缓存失败: {out}") raise CustomException(msg="同步配置到缓存失败") except Exception as e: - log.error(f"创建字典类型失败: {e}") + logger.error(f"创建字典类型失败: {e}") raise CustomException(msg=f"创建字典类型失败 {e}") - return new_obj_dict + return out @classmethod async def update_obj_service( cls, auth: AuthSchema, redis: Redis, id: int, data: ParamsUpdateSchema - ) -> dict: + ) -> ParamsOutSchema: """ 更新配置管理型 @@ -188,17 +193,16 @@ class ParamsService: 返回: - Dict: 更新后的配置管理型模型实例字典表示 """ - exist_obj = await ParamsCRUD(auth).get_obj_by_id_crud(id=id) + exist_obj = await ParamsCRUD(auth).get(id=id) if not exist_obj: raise CustomException(msg="更新失败，该数系统配置不存在") if exist_obj.config_key != data.config_key: raise CustomException(msg="更新失败，系统配置key不允许修改") - new_obj = await ParamsCRUD(auth).update_obj_crud(id=id, data=data) + new_obj = await ParamsCRUD(auth).update(id=id, data=data) if not new_obj: raise CustomException(msg="更新失败，系统配置不存在") out = ParamsOutSchema.model_validate(new_obj) - new_obj_dict = out.model_dump() redis_payload = out.model_dump(mode="json") # 同步redis @@ -213,13 +217,13 @@ class ParamsService: expire=None, ) if not result: - log.error(f"同步配置到缓存失败: {new_obj_dict}") + logger.error(f"同步配置到缓存失败: {out}") raise CustomException(msg="同步配置到缓存失败") except Exception as e: - log.error(f"更新系统配置失败: {e}") + logger.error(f"更新系统配置失败: {e}") raise CustomException(msg="更新系统配置失败") - return new_obj_dict + return out @classmethod async def delete_obj_service(cls, auth: AuthSchema, redis: Redis, ids: list[int]) -> None: @@ -236,30 +240,27 @@ class ParamsService: """ if len(ids) < 1: raise CustomException(msg="删除失败，删除对象不能为空") - for id in ids: - exist_obj = await ParamsCRUD(auth).get_obj_by_id_crud(id=id) - if not exist_obj: + # 批量校验参数存在性 + objs = await ParamsCRUD(auth).list(search={"id": ("in", ids)}) + obj_map = {o.id: o for o in objs} + for pid in ids: + obj = obj_map.get(pid) + if not obj: raise CustomException(msg="删除失败，该数据字典类型不存在") - # 检查是否是否初始化类型 - if exist_obj.config_type: - # 如果有字典数据，不能删除 + if obj.config_type: raise CustomException( - msg=f"{exist_obj.config_name} 删除失败，系统初始化配置不可以删除" + msg=f"{obj.config_name} 删除失败，系统初始化配置不可以删除" ) - await ParamsCRUD(auth).delete_obj_crud(ids=ids) + await ParamsCRUD(auth).delete(ids=ids) - # 同步删除Redis缓存 - for id in ids: - exist_obj = await ParamsCRUD(auth).get_obj_by_id_crud(id=id) - if not exist_obj: - continue - redis_key = f"{RedisInitKeyConfig.SYSTEM_CONFIG.key}:{auth.user.tenant_id}:{exist_obj.config_key}" + # 同步删除Redis缓存（使用删除前已获取的对象信息） + for obj in objs: + redis_key = f"{RedisInitKeyConfig.SYSTEM_CONFIG.key}:{auth.user.tenant_id}:{obj.config_key}" try: await RedisCURD(redis).delete(redis_key) - log.info(f"删除系统配置成功: {id}") except Exception as e: - log.error(f"删除系统配置失败: {e}") + logger.error(f"删除系统配置失败: {e}") raise CustomException(msg="删除字典类型失败") @classmethod @@ -277,12 +278,8 @@ class ParamsService: """ if not ids: raise CustomException(msg="请选择要操作的数据") - - await ParamsCRUD(auth).update_obj_crud( - ids=ids, - data={"status": status}, - ) - log.info(f"批量设置系统参数状态成功: ids={ids}, status={status}") + + await ParamsCRUD(auth).set(ids=ids, status=status) @classmethod async def export_obj_service(cls, data_list: list[dict]) -> bytes: @@ -313,11 +310,6 @@ class ParamsService: for item in data: # 处理状态 item["config_type"] = "是" if item.get("config_type") else "否" - item["creator"] = ( - item.get("creator", {}).get("name", "未知") - if isinstance(item.get("creator"), dict) - else "未知" - ) return ExcelUtil.export_list2excel(list_data=data, mapping_dict=mapping_dict) @@ -335,7 +327,7 @@ class ParamsService: async with async_db_session() as session: async with session.begin(): auth = AuthSchema(db=session, check_data_scope=False) - config_obj = await ParamsCRUD(auth).get_obj_list_crud() + config_obj = await ParamsCRUD(auth).list() if not config_obj: raise CustomException(msg="系统配置不存在") try: @@ -343,7 +335,6 @@ class ParamsService: tenant_id = config.tenant_id redis_key = f"{RedisInitKeyConfig.SYSTEM_CONFIG.key}:{tenant_id}:{config.config_key}" out = ParamsOutSchema.model_validate(config) - config_obj_dict = out.model_dump() redis_payload = out.model_dump(mode="json") value = json.dumps(redis_payload, ensure_ascii=False) result = await RedisCURD(redis).set( @@ -352,10 +343,10 @@ class ParamsService: expire=None, ) if not result: - log.error(f"❌️ 初始化系统配置失败: {config_obj_dict}") + logger.error(f"❌️ 初始化系统配置失败: {redis_key}") raise CustomException(msg="初始化系统配置失败") except Exception as e: - log.error(f"❌️ 初始化系统配置失败: {e}") + logger.error(f"❌️ 初始化系统配置失败: {e}") raise CustomException(msg="初始化系统配置失败") @classmethod @@ -382,18 +373,17 @@ class ParamsService: new_config = json.loads(config) configs.append(new_config) except Exception as e: - log.error(f"解析系统配置数据失败: {e}") + logger.error(f"解析系统配置数据失败: {e}") continue # 如果 Redis 中没有数据，从数据库中加载并缓存 if not configs: - log.info("Redis 中没有系统配置数据，从数据库中加载") async with async_db_session() as session: async with session.begin(): - from app.api.v1.module_system.auth.schema import AuthSchema + from app.core.base_schema import AuthSchema auth = AuthSchema(db=session, check_data_scope=False) - config_obj = await ParamsCRUD(auth).get_obj_list_crud() + config_obj = await ParamsCRUD(auth).list() if config_obj: try: for config in config_obj: @@ -408,18 +398,17 @@ class ParamsService: expire=None, ) if not result: - log.error(f"❌️ 缓存系统配置失败: {config_obj_dict}") + logger.error(f"❌️ 缓存系统配置失败: {config_obj_dict}") configs.append(config_obj_dict) - log.info(f"✅️ 已从数据库加载 {len(configs)} 条系统配置到缓存") except Exception as e: - log.error(f"❌️ 加载系统配置失败: {e}") + logger.error(f"❌️ 加载系统配置失败: {e}") return configs @classmethod async def get_system_config_for_middleware(cls, redis: Redis) -> dict: """ - 获取中间件所需的系统配置 + 获取中间件所需的系统配置（带 60 秒内存缓存，避免每请求查 Redis）。 参数: - redis (Redis): Redis 客户端实例 @@ -427,6 +416,17 @@ class ParamsService: 返回: - dict: 包含演示模式、IP白名单、API白名单和IP黑名单的配置字典 """ + now = time.monotonic() + if _mid_config_cache["data"] and now - _mid_config_cache["ts"] < _MID_CONFIG_TTL: + return _mid_config_cache["data"] + + config_result = await cls._fetch_system_config_for_middleware(redis) + _mid_config_cache["data"] = config_result + _mid_config_cache["ts"] = now + return config_result + + @classmethod + async def _fetch_system_config_for_middleware(cls, redis: Redis) -> dict: # 定义需要获取的配置键 config_keys = [ f"{RedisInitKeyConfig.SYSTEM_CONFIG.key}:1:demo_enable", @@ -456,7 +456,7 @@ class ParamsService: else False ) except json.JSONDecodeError: - log.error("解析演示模式配置失败") + logger.error("解析演示模式配置失败") # 解析IP白名单配置 if config_values[1]: @@ -465,7 +465,7 @@ class ParamsService: # 确保是列表类型 config_result["ip_white_list"] = json.loads(ip_white_config.get("config_value", [])) except json.JSONDecodeError: - log.error("解析IP白名单配置失败") + logger.error("解析IP白名单配置失败") # 解析IP黑名单 # 解析API路径白名单 if config_values[2]: @@ -476,7 +476,7 @@ class ParamsService: white_api_config.get("config_value", []) ) except json.JSONDecodeError: - log.error("解析API白名单配置失败") + logger.error("解析API白名单配置失败") # 解析IP黑名单 if config_values[3]: @@ -485,5 +485,5 @@ class ParamsService: # 确保是列表类型 config_result["ip_black_list"] = json.loads(black_ip_config.get("config_value", [])) except json.JSONDecodeError: - log.error("解析IP黑名单配置失败") + logger.error("解析IP黑名单配置失败") return config_result diff --git a/backend/app/api/v1/module_system/position/controller.py b/backend/app/api/v1/module_system/position/controller.py index d7089b54..ba7382b7 100644 --- a/backend/app/api/v1/module_system/position/controller.py +++ b/backend/app/api/v1/module_system/position/controller.py @@ -2,13 +2,13 @@ from typing import Annotated from fastapi import APIRouter, Body, Depends, Path from fastapi.responses import JSONResponse, StreamingResponse +from fastapi_cache import FastAPICache +from fastapi_cache.decorator import cache -from app.api.v1.module_system.auth.schema import AuthSchema from app.common.response import ResponseSchema, StreamResponse, SuccessResponse from app.core.base_params import PaginationQueryParam -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable, PageResultSchema from app.core.dependencies import AuthPermission -from app.core.logger import log from app.core.router_class import OperationLogRoute from app.utils.common_util import bytes2file_response @@ -20,19 +20,21 @@ from .schema import ( ) from .service import PositionService -PositionRouter = APIRouter(route_class=OperationLogRoute, prefix="/position", tags=["岗位管理"]) +PositionRouter = APIRouter(route_class=OperationLogRoute, prefix="/position", tags=["系统管理/岗位管理"]) + +_POS_NS = "position" @PositionRouter.get( "/list", summary="查询岗位", - description="查询岗位", - response_model=ResponseSchema[list[PositionOutSchema]], + response_model=ResponseSchema[PageResultSchema[PositionOutSchema]], ) +@cache(expire=300, namespace=_POS_NS) async def get_obj_list_controller( page: Annotated[PaginationQueryParam, Depends()], search: Annotated[PositionQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:position:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:position:query']))], ) -> JSONResponse: """ 查询岗位列表 @@ -55,19 +57,17 @@ async def get_obj_list_controller( search=search, order_by=order_by, ) - log.info("查询岗位列表成功") return SuccessResponse(data=result_dict, msg="查询岗位列表成功") @PositionRouter.get( "/detail/{id}", summary="查询岗位详情", - description="查询岗位详情", response_model=ResponseSchema[PositionOutSchema], ) async def get_obj_detail_controller( id: Annotated[int, Path(description="岗位ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:position:detail"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:position:detail']))], ) -> JSONResponse: """ 查询岗位详情 @@ -80,19 +80,17 @@ async def get_obj_detail_controller( - JSONResponse: 岗位详情对象 """ result_dict = await PositionService.get_position_detail_service(id=id, auth=auth) - log.info(f"查询岗位详情成功 {id}") return SuccessResponse(data=result_dict, msg="获取岗位详情成功") @PositionRouter.post( "/create", summary="创建岗位", - description="创建岗位", response_model=ResponseSchema[PositionOutSchema], ) async def create_obj_controller( data: PositionCreateSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:position:create"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:position:create']))], ) -> JSONResponse: """ 创建岗位 @@ -105,20 +103,19 @@ async def create_obj_controller( - JSONResponse: 岗位详情对象 """ result_dict = await PositionService.create_position_service(data=data, auth=auth) - log.info(f"创建岗位成功: {result_dict}") + await FastAPICache.clear(namespace=_POS_NS) return SuccessResponse(data=result_dict, msg="创建岗位成功") @PositionRouter.put( "/update/{id}", summary="修改岗位", - description="修改岗位", response_model=ResponseSchema[PositionOutSchema], ) async def update_obj_controller( data: PositionUpdateSchema, id: Annotated[int, Path(description="岗位ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:position:update"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:position:update']))], ) -> JSONResponse: """ 修改岗位 @@ -132,19 +129,18 @@ async def update_obj_controller( - JSONResponse: 岗位详情对象 """ result_dict = await PositionService.update_position_service(id=id, data=data, auth=auth) - log.info(f"修改岗位成功: {result_dict}") + await FastAPICache.clear(namespace=_POS_NS) return SuccessResponse(data=result_dict, msg="修改岗位成功") @PositionRouter.delete( "/delete", summary="删除岗位", - description="删除岗位", response_model=ResponseSchema[None], ) async def delete_obj_controller( ids: Annotated[list[int], Body(description="ID列表")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:position:delete"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:position:delete']))], ) -> JSONResponse: """ 删除岗位 @@ -157,19 +153,18 @@ async def delete_obj_controller( - JSONResponse: 成功消息 """ await PositionService.delete_position_service(ids=ids, auth=auth) - log.info(f"删除岗位成功: {ids}") + await FastAPICache.clear(namespace=_POS_NS) return SuccessResponse(msg="删除岗位成功") @PositionRouter.patch( "/status/batch", summary="批量修改岗位状态", - description="批量修改岗位状态", response_model=ResponseSchema[None], ) async def batch_set_available_obj_controller( data: BatchSetAvailable, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:position:patch"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:position:patch']))], ) -> JSONResponse: """ 批量修改岗位状态 @@ -182,19 +177,18 @@ async def batch_set_available_obj_controller( - JSONResponse: 成功消息 """ await PositionService.set_position_available_service(data=data, auth=auth) - log.info(f"批量修改岗位状态成功: {data.ids}") + await FastAPICache.clear(namespace=_POS_NS) return SuccessResponse(msg="批量修改岗位状态成功") @PositionRouter.get( "/export", summary="导出岗位", - description="导出岗位列表", response_model=ResponseSchema[None], ) async def export_obj_list_controller( search: Annotated[PositionQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:position:export"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:position:export']))], ) -> StreamingResponse: """ 导出岗位 @@ -212,7 +206,6 @@ async def export_obj_list_controller( position_export_result = await PositionService.export_position_list_service( position_list=position_query_result ) - log.info("导出岗位成功") return StreamResponse( data=bytes2file_response(position_export_result), diff --git a/backend/app/api/v1/module_system/position/crud.py b/backend/app/api/v1/module_system/position/crud.py index 34d39040..8ac1ade0 100644 --- a/backend/app/api/v1/module_system/position/crud.py +++ b/backend/app/api/v1/module_system/position/crud.py @@ -1,8 +1,5 @@ -from collections.abc import Sequence -from typing import Any - -from app.api.v1.module_system.auth.schema import AuthSchema from app.core.base_crud import CRUDBase +from app.core.base_schema import AuthSchema from .model import PositionModel from .schema import PositionCreateSchema, PositionUpdateSchema @@ -21,69 +18,4 @@ class PositionCRUD(CRUDBase[PositionModel, PositionCreateSchema, PositionUpdateS 返回: - None """ - self.auth = auth super().__init__(model=PositionModel, auth=auth) - - async def get_by_id_crud( - self, id: int, preload: list[str] | None = None - ) -> PositionModel | None: - """ - 根据 id 获取岗位信息。 - - 参数: - - id (int): 岗位 ID。 - - preload (list[str] | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - PositionModel | None: 岗位信息，未找到返回 None。 - """ - return await self.get(id=id, preload=preload) - - async def get_list_crud( - self, - search: dict | None = None, - order_by: list[dict[str, Any]] | None = None, - preload: list[str] | None = None, - ) -> Sequence[PositionModel]: - """ - 获取岗位列表。 - - 参数: - - search (dict | None): 搜索条件。 - - order_by (list[dict[str, Any]] | None): 排序字段列表。 - - preload (list[str] | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - Sequence[PositionModel]: 岗位列表。 - """ - return await self.list(search=search, order_by=order_by, preload=preload) - - async def set_available_crud(self, ids: list[int], status: str) -> None: - """ - 批量设置岗位可用状态。 - - 参数: - - ids (list[int]): 岗位 ID 列表。 - - status (bool): 可用状态。 - - 返回: - - None - """ - await self.set(ids=ids, status=status) - - async def get_name_crud(self, ids: list[int]) -> list[str]: - """ - 根据 id 列表获取岗位名称。 - - 参数: - - ids (list[int]): 岗位 ID 列表。 - - 返回: - - list[str]: 岗位名称列表。 - """ - position_names = [] - for id in ids: - obj = await self.get(id=id) - if obj: - position_names.append(obj.name) - return position_names diff --git a/backend/app/api/v1/module_system/position/schema.py b/backend/app/api/v1/module_system/position/schema.py index d721a51f..7b16e13a 100644 --- a/backend/app/api/v1/module_system/position/schema.py +++ b/backend/app/api/v1/module_system/position/schema.py @@ -12,7 +12,7 @@ class PositionCreateSchema(BaseModel): name: str = Field(..., min_length=1, max_length=64, description="岗位名称") code: str = Field(..., min_length=1, max_length=64, description="岗位编码") order: int = Field(default=1, ge=0, description="显示排序") - status: str = Field(default="0", max_length=1, description="状态(0:正常 1:禁用)") + status: int = Field(default=0, ge=0, le=1, description="状态(0:正常 1:禁用)") description: str | None = Field(default=None, max_length=255, description="描述") @field_validator("name") @@ -33,8 +33,8 @@ class PositionCreateSchema(BaseModel): @field_validator("status") @classmethod - def _validate_status(cls, v: str) -> str: - if v not in {"0", "1"}: + def _validate_status(cls, v: int) -> int: + if v not in {0, 1}: raise ValueError("状态仅支持 0(正常) 或 1(禁用)") return v diff --git a/backend/app/api/v1/module_system/position/service.py b/backend/app/api/v1/module_system/position/service.py index b6e38913..ded1c48b 100644 --- a/backend/app/api/v1/module_system/position/service.py +++ b/backend/app/api/v1/module_system/position/service.py @@ -1,5 +1,4 @@ -from app.api.v1.module_system.auth.schema import AuthSchema -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable from app.core.exceptions import CustomException from app.utils.excel_util import ExcelUtil @@ -16,7 +15,7 @@ class PositionService: """岗位模块服务层""" @classmethod - async def get_position_detail_service(cls, auth: AuthSchema, id: int) -> dict: + async def get_position_detail_service(cls, auth: AuthSchema, id: int) -> PositionOutSchema: """ 获取岗位详情 @@ -27,8 +26,10 @@ class PositionService: 返回: - Dict: 岗位详情对象 """ - position = await PositionCRUD(auth).get_by_id_crud(id=id) - return PositionOutSchema.model_validate(position).model_dump() + position = await PositionCRUD(auth).get(id=id) + if not position: + raise CustomException(msg="岗位不存在") + return PositionOutSchema.model_validate(position) @classmethod async def get_position_list_service( @@ -36,7 +37,7 @@ class PositionService: auth: AuthSchema, search: PositionQueryParam | None = None, order_by: list[dict] | None = None, - ) -> list[dict]: + ) -> list[PositionOutSchema]: """ 获取岗位列表 @@ -46,13 +47,13 @@ class PositionService: - order_by (list[dict] | None): 排序参数列表 返回: - - list[dict]: 岗位列表对象 + - list[PositionOutSchema]: 岗位列表 """ - position_list = await PositionCRUD(auth).get_list_crud( - search=search.__dict__, order_by=order_by + position_list = await PositionCRUD(auth).list( + search=search.__dict__ if search else {}, order_by=order_by ) return [ - PositionOutSchema.model_validate(position).model_dump() for position in position_list + PositionOutSchema.model_validate(position) for position in position_list ] @classmethod @@ -87,7 +88,7 @@ class PositionService: ) @classmethod - async def create_position_service(cls, auth: AuthSchema, data: PositionCreateSchema) -> dict: + async def create_position_service(cls, auth: AuthSchema, data: PositionCreateSchema) -> PositionOutSchema: """ 创建岗位 @@ -102,12 +103,12 @@ class PositionService: if position: raise CustomException(msg="创建失败，该岗位已存在") new_position = await PositionCRUD(auth).create(data=data) - return PositionOutSchema.model_validate(new_position).model_dump() + return PositionOutSchema.model_validate(new_position) @classmethod async def update_position_service( cls, auth: AuthSchema, id: int, data: PositionUpdateSchema - ) -> dict: + ) -> PositionOutSchema: """ 更新岗位 @@ -119,14 +120,14 @@ class PositionService: 返回: - dict: 更新的岗位对象 """ - position = await PositionCRUD(auth).get_by_id_crud(id=id) + position = await PositionCRUD(auth).get(id=id) if not position: raise CustomException(msg="更新失败，该岗位不存在") exist_position = await PositionCRUD(auth).get(name=data.name) if exist_position and exist_position.id != id: raise CustomException(msg="更新失败，岗位名称重复") updated_position = await PositionCRUD(auth).update(id=id, data=data) - return PositionOutSchema.model_validate(updated_position).model_dump() + return PositionOutSchema.model_validate(updated_position) @classmethod async def delete_position_service(cls, auth: AuthSchema, ids: list[int]) -> None: @@ -142,9 +143,11 @@ class PositionService: """ if len(ids) < 1: raise CustomException(msg="删除失败，删除对象不能为空") - for id in ids: - position = await PositionCRUD(auth).get_by_id_crud(id=id) - if not position: + # 批量校验岗位存在性 + positions = await PositionCRUD(auth).list(search={"id": ("in", ids)}) + position_map = {p.id: p for p in positions} + for pid in ids: + if pid not in position_map: raise CustomException(msg="删除失败，该岗位不存在") await PositionCRUD(auth).delete(ids=ids) @@ -162,7 +165,12 @@ class PositionService: 返回: - None """ - await PositionCRUD(auth).set_available_crud(ids=data.ids, status=data.status) + positions = await PositionCRUD(auth).list(search={"id": ("in", data.ids)}) + position_map = {p.id: p for p in positions} + for pid in data.ids: + if pid not in position_map: + raise CustomException(msg=f"岗位ID {pid} 不存在") + await PositionCRUD(auth).set(ids=data.ids, status=data.status) @classmethod async def export_position_list_service(cls, position_list: list[dict]) -> bytes: @@ -192,8 +200,8 @@ class PositionService: for item in data: item["status"] = "启用" if item.get("status") == "0" else "停用" item["creator"] = ( - item.get("creator", {}).get("name", "未知") - if isinstance(item.get("creator"), dict) + item.get("created_by", {}).get("name", "未知") + if isinstance(item.get("created_by"), dict) else "未知" ) diff --git a/backend/app/api/v1/module_system/role/controller.py b/backend/app/api/v1/module_system/role/controller.py index 36165b88..0e114d9a 100644 --- a/backend/app/api/v1/module_system/role/controller.py +++ b/backend/app/api/v1/module_system/role/controller.py @@ -2,13 +2,13 @@ from typing import Annotated from fastapi import APIRouter, Body, Depends, Path from fastapi.responses import JSONResponse, StreamingResponse +from fastapi_cache import FastAPICache +from fastapi_cache.decorator import cache -from app.api.v1.module_system.auth.schema import AuthSchema from app.common.response import ResponseSchema, StreamResponse, SuccessResponse from app.core.base_params import PaginationQueryParam -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable, PageResultSchema from app.core.dependencies import AuthPermission -from app.core.logger import log from app.core.router_class import OperationLogRoute from app.utils.common_util import bytes2file_response @@ -21,19 +21,21 @@ from .schema import ( ) from .service import RoleService -RoleRouter = APIRouter(route_class=OperationLogRoute, prefix="/role", tags=["角色管理"]) +RoleRouter = APIRouter(route_class=OperationLogRoute, prefix="/role", tags=["系统管理/角色管理"]) + +_ROLE_NS = "role" @RoleRouter.get( "/list", summary="查询角色", - description="查询角色", - response_model=ResponseSchema[list[RoleOutSchema]], + response_model=ResponseSchema[PageResultSchema[RoleOutSchema]], ) +@cache(expire=300, namespace=_ROLE_NS) async def get_obj_list_controller( page: Annotated[PaginationQueryParam, Depends()], search: Annotated[RoleQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:role:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:role:query']))], ) -> JSONResponse: """ 查询角色 @@ -56,19 +58,17 @@ async def get_obj_list_controller( search=search, order_by=order_by, ) - log.info("查询角色成功") return SuccessResponse(data=result_dict, msg="查询角色成功") @RoleRouter.get( "/detail/{id}", summary="查询角色详情", - description="查询角色详情", response_model=ResponseSchema[RoleOutSchema], ) async def get_obj_detail_controller( id: Annotated[int, Path(description="角色ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:role:detail"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:role:detail']))], ) -> JSONResponse: """ 查询角色详情 @@ -81,19 +81,17 @@ async def get_obj_detail_controller( - JSONResponse: 角色详情JSON响应 """ result_dict = await RoleService.get_role_detail_service(id=id, auth=auth) - log.info(f"获取角色详情成功 {id}") return SuccessResponse(data=result_dict, msg="获取角色详情成功") @RoleRouter.post( "/create", summary="创建角色", - description="创建角色", response_model=ResponseSchema[RoleOutSchema], ) async def create_obj_controller( data: RoleCreateSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:role:create"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:role:create']))], ) -> JSONResponse: """ 创建角色 @@ -106,20 +104,19 @@ async def create_obj_controller( - JSONResponse: 创建角色JSON响应 """ result_dict = await RoleService.create_role_service(data=data, auth=auth) - log.info(f"创建角色成功: {result_dict}") + await FastAPICache.clear(namespace=_ROLE_NS) return SuccessResponse(data=result_dict, msg="创建角色成功") @RoleRouter.put( "/update/{id}", summary="修改角色", - description="修改角色", response_model=ResponseSchema[RoleOutSchema], ) async def update_obj_controller( data: RoleUpdateSchema, id: Annotated[int, Path(description="角色ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:role:update"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:role:update']))], ) -> JSONResponse: """ 修改角色 @@ -133,19 +130,18 @@ async def update_obj_controller( - JSONResponse: 修改角色JSON响应 """ result_dict = await RoleService.update_role_service(id=id, data=data, auth=auth) - log.info(f"修改角色成功: {result_dict}") + await FastAPICache.clear(namespace=_ROLE_NS) return SuccessResponse(data=result_dict, msg="修改角色成功") @RoleRouter.delete( "/delete", summary="删除角色", - description="删除角色", response_model=ResponseSchema[None], ) async def delete_obj_controller( ids: Annotated[list[int], Body(description="ID列表")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:role:delete"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:role:delete']))], ) -> JSONResponse: """ 删除角色 @@ -158,19 +154,18 @@ async def delete_obj_controller( - JSONResponse: 删除角色JSON响应 """ await RoleService.delete_role_service(ids=ids, auth=auth) - log.info(f"删除角色成功: {ids}") + await FastAPICache.clear(namespace=_ROLE_NS) return SuccessResponse(msg="删除角色成功") @RoleRouter.patch( "/status/batch", summary="批量修改角色状态", - description="批量修改角色状态", response_model=ResponseSchema[None], ) async def batch_set_available_obj_controller( data: BatchSetAvailable, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:role:patch"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:role:patch']))], ) -> JSONResponse: """ 批量修改角色状态 @@ -183,19 +178,18 @@ async def batch_set_available_obj_controller( - JSONResponse: 批量修改角色状态JSON响应 """ await RoleService.set_role_available_service(data=data, auth=auth) - log.info(f"批量修改角色状态成功: {data.ids}") + await FastAPICache.clear(namespace=_ROLE_NS) return SuccessResponse(msg="批量修改角色状态成功") @RoleRouter.put( "/permission", summary="角色授权", - description="设置角色权限", response_model=ResponseSchema[None], ) async def set_role_permission_controller( data: RolePermissionSettingSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:role:permission"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:role:permission']))], ) -> JSONResponse: """ 角色授权 @@ -208,19 +202,18 @@ async def set_role_permission_controller( - JSONResponse: 角色授权JSON响应 """ await RoleService.set_role_permission_service(data=data, auth=auth) - log.info(f"设置角色权限成功: {data}") + await FastAPICache.clear(namespace=_ROLE_NS) return SuccessResponse(msg="授权角色成功") @RoleRouter.get( "/export", summary="导出角色", - description="导出角色列表", response_model=ResponseSchema[None], ) async def export_obj_list_controller( search: Annotated[RoleQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:role:export"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:role:export']))], ) -> StreamingResponse: """ 导出角色 @@ -234,7 +227,6 @@ async def export_obj_list_controller( """ role_query_result = await RoleService.get_role_list_service(search=search, auth=auth) role_export_result = await RoleService.export_role_list_service(role_list=role_query_result) - log.info("导出角色成功") return StreamResponse( data=bytes2file_response(role_export_result), diff --git a/backend/app/api/v1/module_system/role/crud.py b/backend/app/api/v1/module_system/role/crud.py index 2f55ffab..52e02293 100644 --- a/backend/app/api/v1/module_system/role/crud.py +++ b/backend/app/api/v1/module_system/role/crud.py @@ -1,9 +1,8 @@ -from collections.abc import Sequence -from app.api.v1.module_system.auth.schema import AuthSchema +from app.api.v1.module_platform.menu.crud import MenuCRUD from app.api.v1.module_system.dept.crud import DeptCRUD -from app.api.v1.module_system.menu.crud import MenuCRUD from app.core.base_crud import CRUDBase +from app.core.base_schema import AuthSchema from app.core.exceptions import CustomException from .model import RoleModel @@ -23,41 +22,8 @@ class RoleCRUD(CRUDBase[RoleModel, RoleCreateSchema, RoleUpdateSchema]): 返回: - None """ - self.auth = auth super().__init__(model=RoleModel, auth=auth) - async def get_by_id_crud(self, id: int, preload: list | None = None) -> RoleModel | None: - """ - 根据id获取角色信息 - - 参数: - - id (int): 角色ID - - preload (list | None): 预加载选项 - - 返回: - - RoleModel | None: 角色模型对象 - """ - return await self.get(id=id, preload=preload) - - async def get_list_crud( - self, - search: dict | None = None, - order_by: list | None = None, - preload: list | None = None, - ) -> Sequence[RoleModel]: - """ - 获取角色列表 - - 参数: - - search (dict | None): 查询参数 - - order_by (list | None): 排序参数 - - preload (list | None): 预加载选项 - - 返回: - - Sequence[RoleModel]: 角色模型对象列表 - """ - return await self.list(search=search, order_by=order_by, preload=preload) - async def set_role_menus_crud(self, role_ids: list[int], menu_ids: list[int]) -> None: """ 设置角色的菜单权限 @@ -70,18 +36,16 @@ class RoleCRUD(CRUDBase[RoleModel, RoleCreateSchema, RoleUpdateSchema]): - None """ roles = await self.list(search={"id": ("in", role_ids)}) - # 前端未勾选时 menu_ids 可能为空：此时应清空关联，而不是触发全量查询 menus = ( [] if not menu_ids - else await MenuCRUD(self.auth).get_list_crud(search={"id": ("in", menu_ids)}) + else await MenuCRUD(self.auth).list(search={"id": ("in", menu_ids)}) ) - # 租户菜单约束：只允许分配租户菜单权限内的菜单 - from app.api.v1.module_platform.tenant.service import TenantService + from app.api.v1.module_platform.package.service import PackageService if self.auth.user and not self.auth.user.is_superuser and self.auth.tenant_id: - allowed_menu_ids = await TenantService.get_tenant_menu_ids( + allowed_menu_ids = await PackageService.get_tenant_available_menu_ids( self.auth, self.auth.tenant_id ) allowed_set = set(allowed_menu_ids) @@ -95,19 +59,6 @@ class RoleCRUD(CRUDBase[RoleModel, RoleCreateSchema, RoleUpdateSchema]): relationship.extend(menus) await self.auth.db.flush() - async def set_role_data_scope_crud(self, role_ids: list[int], data_scope: int) -> None: - """ - 设置角色的数据范围 - - 参数: - - role_ids (list[int]): 角色ID列表 - - data_scope (int): 数据范围 - - 返回: - - None - """ - await self.set(ids=role_ids, data_scope=data_scope) - async def set_role_depts_crud(self, role_ids: list[int], dept_ids: list[int]) -> None: """ 设置角色的部门权限 @@ -120,11 +71,10 @@ class RoleCRUD(CRUDBase[RoleModel, RoleCreateSchema, RoleUpdateSchema]): - None """ roles = await self.list(search={"id": ("in", role_ids)}) - # 前端未勾选时 dept_ids 可能为空：此时应清空关联，而不是触发全量查询 depts = ( [] if not dept_ids - else await DeptCRUD(self.auth).get_list_crud(search={"id": ("in", dept_ids)}) + else await DeptCRUD(self.auth).list(search={"id": ("in", dept_ids)}) ) for obj in roles: @@ -132,16 +82,3 @@ class RoleCRUD(CRUDBase[RoleModel, RoleCreateSchema, RoleUpdateSchema]): relationship.clear() relationship.extend(depts) await self.auth.db.flush() - - async def set_available_crud(self, ids: list[int], status: str) -> None: - """ - 设置角色的可用状态 - - 参数: - - ids (list[int]): 角色ID列表 - - status (str): 可用状态 - - 返回: - - None - """ - await self.set(ids=ids, status=status) diff --git a/backend/app/api/v1/module_system/role/model.py b/backend/app/api/v1/module_system/role/model.py index cea72545..2ca521ef 100644 --- a/backend/app/api/v1/module_system/role/model.py +++ b/backend/app/api/v1/module_system/role/model.py @@ -7,8 +7,8 @@ from app.common.enums import PermissionFilterStrategy from app.core.base_model import MappedBase, ModelMixin, TenantMixin if TYPE_CHECKING: + from app.api.v1.module_platform.menu.model import MenuModel from app.api.v1.module_system.dept.model import DeptModel - from app.api.v1.module_system.menu.model import MenuModel from app.api.v1.module_system.user.model import UserModel @@ -30,7 +30,7 @@ class RoleMenusModel(MappedBase): ) menu_id: Mapped[int] = mapped_column( Integer, - ForeignKey("sys_menu.id", ondelete="CASCADE", onupdate="CASCADE"), + ForeignKey("platform_menu.id", ondelete="CASCADE", onupdate="CASCADE"), primary_key=True, comment="菜单ID", ) diff --git a/backend/app/api/v1/module_system/role/schema.py b/backend/app/api/v1/module_system/role/schema.py index c1e3ce07..7184343a 100644 --- a/backend/app/api/v1/module_system/role/schema.py +++ b/backend/app/api/v1/module_system/role/schema.py @@ -7,8 +7,8 @@ from pydantic import ( model_validator, ) +from app.api.v1.module_platform.menu.schema import MenuOutSchema from app.api.v1.module_system.dept.schema import DeptOutSchema -from app.api.v1.module_system.menu.schema import MenuOutSchema from app.common.enums import QueueEnum from app.core.base_schema import BaseSchema from app.core.validator import ( @@ -30,7 +30,7 @@ class RoleCreateSchema(BaseModel): le=5, description="数据权限范围(1:仅本人 2:本部门 3:本部门及以下 4:全部 5:自定义)", ) - status: str = Field(default="0", max_length=1, description="状态(0:正常 1:禁用)") + status: int = Field(default=0, ge=0, le=1, description="状态(0:正常 1:禁用)") description: str | None = Field(default=None, max_length=255, description="描述") @field_validator("code") @@ -41,9 +41,9 @@ class RoleCreateSchema(BaseModel): @field_validator("status") @classmethod - def validate_status(cls, value: str): + def validate_status(cls, value: int): """校验状态：仅支持 0(正常)、1(禁用)""" - if value not in {"0", "1"}: + if value not in {0, 1}: raise ValueError("状态仅支持 0(正常) 或 1(禁用)") return value diff --git a/backend/app/api/v1/module_system/role/service.py b/backend/app/api/v1/module_system/role/service.py index 7e659da5..32563dbd 100644 --- a/backend/app/api/v1/module_system/role/service.py +++ b/backend/app/api/v1/module_system/role/service.py @@ -1,7 +1,6 @@ from typing import Any -from app.api.v1.module_system.auth.schema import AuthSchema -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable from app.core.exceptions import CustomException from app.utils.excel_util import ExcelUtil @@ -19,7 +18,7 @@ class RoleService: """角色模块服务层""" @classmethod - async def get_role_detail_service(cls, auth: AuthSchema, id: int) -> dict: + async def get_role_detail_service(cls, auth: AuthSchema, id: int) -> RoleOutSchema: """ 获取角色详情 @@ -30,8 +29,10 @@ class RoleService: 返回: - dict: 角色详情字典 """ - role = await RoleCRUD(auth).get_by_id_crud(id=id) - return RoleOutSchema.model_validate(role).model_dump() + role = await RoleCRUD(auth).get(id=id) + if not role: + raise CustomException(msg="角色不存在") + return RoleOutSchema.model_validate(role) @classmethod async def get_role_list_service( @@ -39,7 +40,7 @@ class RoleService: auth: AuthSchema, search: RoleQueryParam | None = None, order_by: list[dict[str, str]] | None = None, - ) -> list[dict]: + ) -> list[RoleOutSchema]: """ 获取角色列表 @@ -49,10 +50,12 @@ class RoleService: - order_by (list[dict[str, str]] | None): 排序参数列表 返回: - - list[dict]: 角色详情字典列表 + - list[RoleOutSchema]: 角色详情字典列表 """ - role_list = await RoleCRUD(auth).get_list_crud(search=search.__dict__, order_by=order_by) - return [RoleOutSchema.model_validate(role).model_dump() for role in role_list] + role_list = await RoleCRUD(auth).list( + search=search.__dict__ if search else {}, order_by=order_by + ) + return [RoleOutSchema.model_validate(role) for role in role_list] @classmethod async def get_role_page_service( @@ -86,7 +89,7 @@ class RoleService: ) @classmethod - async def create_role_service(cls, auth: AuthSchema, data: RoleCreateSchema) -> dict: + async def create_role_service(cls, auth: AuthSchema, data: RoleCreateSchema) -> RoleOutSchema: """ 创建角色 @@ -109,10 +112,10 @@ class RoleService: await TenantService.check_quota_service(auth, auth.tenant_id, "role") new_role = await RoleCRUD(auth).create(data=data) - return RoleOutSchema.model_validate(new_role).model_dump() + return RoleOutSchema.model_validate(new_role) @classmethod - async def update_role_service(cls, auth: AuthSchema, id: int, data: RoleUpdateSchema) -> dict: + async def update_role_service(cls, auth: AuthSchema, id: int, data: RoleUpdateSchema) -> RoleOutSchema: """ 更新角色 @@ -124,7 +127,7 @@ class RoleService: 返回: - dict: 更新后的角色详情字典 """ - role = await RoleCRUD(auth).get_by_id_crud(id=id) + role = await RoleCRUD(auth).get(id=id) if not role: raise CustomException(msg="更新失败，该角色不存在") exist_role = await RoleCRUD(auth).get(name=data.name) @@ -134,7 +137,7 @@ class RoleService: if exist_code and exist_code.id != id: raise CustomException(msg="更新失败，角色编码已存在") updated_role = await RoleCRUD(auth).update(id=id, data=data) - return RoleOutSchema.model_validate(updated_role).model_dump() + return RoleOutSchema.model_validate(updated_role) @classmethod async def delete_role_service(cls, auth: AuthSchema, ids: list[int]) -> None: @@ -150,10 +153,14 @@ class RoleService: """ if len(ids) < 1: raise CustomException(msg="删除失败，删除对象不能为空") - for id in ids: - role = await RoleCRUD(auth).get_by_id_crud(id=id) - if not role: - raise CustomException(msg="删除失败，该角色不存在") + + # 批量校验角色存在性 + roles = await RoleCRUD(auth).list(search={"id": ("in", ids)}) + if len(roles) != len(ids): + found = {r.id for r in roles} + missing = [rid for rid in ids if rid not in found] + raise CustomException(msg=f"角色 ID {missing} 不存在") + await RoleCRUD(auth).delete(ids=ids) @classmethod @@ -174,9 +181,7 @@ class RoleService: await RoleCRUD(auth).set_role_menus_crud(role_ids=data.role_ids, menu_ids=data.menu_ids) # 设置数据权限范围 - await RoleCRUD(auth).set_role_data_scope_crud( - role_ids=data.role_ids, data_scope=data.data_scope - ) + await RoleCRUD(auth).set(ids=data.role_ids, data_scope=data.data_scope) # 设置自定义数据权限部门 if data.data_scope == 5 and data.dept_ids: @@ -196,7 +201,12 @@ class RoleService: 返回: - None """ - await RoleCRUD(auth).set_available_crud(ids=data.ids, status=data.status) + roles = await RoleCRUD(auth).list(search={"id": ("in", data.ids)}) + role_map = {r.id: r for r in roles} + for rid in data.ids: + if rid not in role_map: + raise CustomException(msg=f"角色ID {rid} 不存在") + await RoleCRUD(auth).set(ids=data.ids, status=data.status) @classmethod async def export_role_list_service(cls, role_list: list[dict[str, Any]]) -> bytes: @@ -237,10 +247,5 @@ class RoleService: for item in data: item["status"] = "启用" if item.get("status") == "0" else "停用" item["data_scope"] = data_scope_map.get(item.get("data_scope", 1), "") - item["creator"] = ( - item.get("creator", {}).get("name", "未知") - if isinstance(item.get("creator"), dict) - else "未知" - ) return ExcelUtil.export_list2excel(list_data=data, mapping_dict=mapping_dict) diff --git a/backend/app/api/v1/module_system/ticket/__init__.py b/backend/app/api/v1/module_system/ticket/__init__.py new file mode 100644 index 00000000..a4d8bf66 --- /dev/null +++ b/backend/app/api/v1/module_system/ticket/__init__.py @@ -0,0 +1,3 @@ +from .controller import TicketRouter + +__all__ = ["TicketRouter"] diff --git a/backend/app/api/v1/module_platform/ticket/controller.py b/backend/app/api/v1/module_system/ticket/controller.py similarity index 50% rename from backend/app/api/v1/module_platform/ticket/controller.py rename to backend/app/api/v1/module_system/ticket/controller.py index 630a9d74..fc147811 100644 --- a/backend/app/api/v1/module_platform/ticket/controller.py +++ b/backend/app/api/v1/module_system/ticket/controller.py @@ -1,12 +1,12 @@ from typing import Annotated from fastapi import APIRouter, Body, Depends, Path +from fastapi.responses import JSONResponse -from app.api.v1.module_system.auth.schema import AuthSchema from app.common.response import ResponseSchema, SuccessResponse from app.core.base_params import PaginationQueryParam +from app.core.base_schema import AuthSchema, PageResultSchema from app.core.dependencies import AuthPermission -from app.core.logger import log from app.core.router_class import OperationLogRoute from .schema import ( @@ -18,15 +18,26 @@ from .schema import ( ) from .service import TicketService -TicketRouter = APIRouter(route_class=OperationLogRoute, prefix="/ticket", tags=["工单管理"]) +TicketRouter = APIRouter(route_class=OperationLogRoute, prefix="/ticket", tags=["系统管理/工单管理"]) -@TicketRouter.get("/list", summary="工单列表", response_model=ResponseSchema[dict]) +@TicketRouter.get("/list", summary="工单列表", response_model=ResponseSchema[PageResultSchema[TicketOutSchema]]) async def ticket_list( page: Annotated[PaginationQueryParam, Depends()], search: Annotated[TicketQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:ticket:query"]))], -): + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:ticket:query']))], +) -> JSONResponse: + """ + 工单列表 + + 参数: + - page (PaginationQueryParam): 分页查询参数。 + - search (TicketQueryParam): 查询筛选参数。 + - auth (AuthSchema): 认证信息模型。 + + 返回: + - JSONResponse: 包含分页工单列表的 JSON 响应。 + """ result = await TicketService.page_service( auth=auth, page_no=page.page_no, @@ -42,8 +53,18 @@ async def ticket_list( ) async def ticket_detail( id: Annotated[int, Path()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:ticket:query"]))], -): + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:ticket:query']))], +) -> JSONResponse: + """ + 工单详情 + + 参数: + - id (int): 工单 ID。 + - auth (AuthSchema): 认证信息模型。 + + 返回: + - JSONResponse: 包含工单详情的 JSON 响应。 + """ result = await TicketService.detail_service(auth=auth, id=id) return SuccessResponse(data=result, msg="查询成功") @@ -51,10 +72,19 @@ async def ticket_detail( @TicketRouter.post("/create", summary="创建工单", response_model=ResponseSchema[TicketOutSchema]) async def ticket_create( data: TicketCreateSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:ticket:create"]))], -): + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:ticket:create']))], +) -> JSONResponse: + """ + 创建工单 + + 参数: + - data (TicketCreateSchema): 工单创建参数。 + - auth (AuthSchema): 认证信息模型。 + + 返回: + - JSONResponse: 包含创建后的工单详情的 JSON 响应。 + """ result = await TicketService.create_service(auth=auth, data=data) - log.info(f"创建工单: {data.title}") return SuccessResponse(data=result, msg="创建成功") @@ -64,28 +94,56 @@ async def ticket_create( async def ticket_update( id: Annotated[int, Path()], data: TicketUpdateSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:ticket:update"]))], -): + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:ticket:update']))], +) -> JSONResponse: + """ + 更新工单 + + 参数: + - id (int): 工单 ID。 + - data (TicketUpdateSchema): 工单更新参数。 + - auth (AuthSchema): 认证信息模型。 + + 返回: + - JSONResponse: 包含更新后的工单详情的 JSON 响应。 + """ result = await TicketService.update_service(auth=auth, id=id, data=data) - log.info(f"更新工单: {id}") return SuccessResponse(data=result, msg="更新成功") @TicketRouter.put("/batch", summary="批量更新工单", response_model=ResponseSchema) async def ticket_batch_update( data: TicketBatchSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:ticket:update"]))], -): + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:ticket:update']))], +) -> JSONResponse: + """ + 批量更新工单 + + 参数: + - data (TicketBatchSchema): 批量更新参数（ID 列表 + 状态）。 + - auth (AuthSchema): 认证信息模型。 + + 返回: + - JSONResponse: 操作结果。 + """ await TicketService.batch_service(auth=auth, data=data) - log.info(f"批量更新工单状态: {data.ids} -> {data.status}") return SuccessResponse(msg="批量更新成功") -@TicketRouter.delete("/delete", summary="删除工单") +@TicketRouter.delete("/delete", summary="删除工单", response_model=ResponseSchema[None]) async def ticket_delete( ids: Annotated[list[int], Body()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:ticket:delete"]))], -): + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:ticket:delete']))], +) -> JSONResponse: + """ + 删除工单 + + 参数: + - ids (list[int]): 工单 ID 列表。 + - auth (AuthSchema): 认证信息模型。 + + 返回: + - JSONResponse: 删除结果。 + """ await TicketService.delete_service(auth=auth, ids=ids) - log.info(f"删除工单: {ids}") return SuccessResponse(msg="删除成功") diff --git a/backend/app/api/v1/module_system/ticket/crud.py b/backend/app/api/v1/module_system/ticket/crud.py new file mode 100644 index 00000000..a646adf5 --- /dev/null +++ b/backend/app/api/v1/module_system/ticket/crud.py @@ -0,0 +1,12 @@ +from app.core.base_crud import CRUDBase +from app.core.base_schema import AuthSchema + +from .model import TicketModel +from .schema import TicketCreateSchema, TicketUpdateSchema + + +class TicketCRUD(CRUDBase[TicketModel, TicketCreateSchema, TicketUpdateSchema]): + """工单 CRUD""" + + def __init__(self, auth: AuthSchema) -> None: + super().__init__(model=TicketModel, auth=auth) diff --git a/backend/app/api/v1/module_platform/ticket/model.py b/backend/app/api/v1/module_system/ticket/model.py similarity index 85% rename from backend/app/api/v1/module_platform/ticket/model.py rename to backend/app/api/v1/module_system/ticket/model.py index 02dd2395..70fb06a9 100644 --- a/backend/app/api/v1/module_platform/ticket/model.py +++ b/backend/app/api/v1/module_system/ticket/model.py @@ -10,9 +10,11 @@ if TYPE_CHECKING: class TicketModel(ModelMixin, TenantMixin, UserMixin): - """工单模型 — 用户提交的建议和反馈""" + """工单模型 — 用户提交的建议和反馈 + status: 0=待处理 1=处理中 2=已完成 3=已关闭 + """ - __tablename__: str = "platform_ticket" + __tablename__: str = "sys_ticket" __table_args__: dict[str, str] = {"comment": "工单表"} __loader_options__: list[str] = ["created_by", "updated_by", "assigned_by"] @@ -29,12 +31,8 @@ class TicketModel(ModelMixin, TenantMixin, UserMixin): default="suggestion", comment="工单类型(suggestion:建议 bug:缺陷 optimize:优化 other:其他)", ) - status: Mapped[str] = mapped_column( - String(10), nullable=False, default="0", comment="状态(0:待处理 1:处理中 2:已完成 3:已关闭)" - ) images: Mapped[str | None] = mapped_column(Text, nullable=True, comment="图片URL列表(JSON数组)") reply: Mapped[str | None] = mapped_column(Text, nullable=True, comment="回复内容") - description: Mapped[str | None] = mapped_column(Text, nullable=True, comment="工单描述") assigned_id: Mapped[int | None] = mapped_column( ForeignKey("sys_user.id", ondelete="SET NULL", onupdate="CASCADE"), nullable=True, diff --git a/backend/app/api/v1/module_platform/ticket/schema.py b/backend/app/api/v1/module_system/ticket/schema.py similarity index 79% rename from backend/app/api/v1/module_platform/ticket/schema.py rename to backend/app/api/v1/module_system/ticket/schema.py index 1d0c1875..18fe9b48 100644 --- a/backend/app/api/v1/module_platform/ticket/schema.py +++ b/backend/app/api/v1/module_system/ticket/schema.py @@ -1,7 +1,9 @@ +from dataclasses import dataclass + from pydantic import BaseModel, ConfigDict, Field, field_validator -from app.core.base_schema import CommonSchema -from app.core.validator import DateTimeStr +from app.common.enums import QueueEnum +from app.core.base_schema import BaseSchema, CommonSchema class TicketCreateSchema(BaseModel): @@ -40,8 +42,8 @@ class TicketUpdateSchema(BaseModel): ticket_content: str | None = Field(default=None, description="工单内容（富文本）") summary: str | None = Field(default=None, description="工单内容（纯文本摘要）") ticket_type: str | None = Field(default=None, max_length=20, description="工单类型") - status: str | None = Field( - default=None, max_length=10, description="状态(0:待处理 1:处理中 2:已完成 3:已关闭)" + status: int | None = Field( + default=None, ge=0, le=3, description="状态(0:待处理 1:处理中 2:已完成 3:已关闭)" ) reply: str | None = Field(default=None, description="回复内容") assigned_id: int | None = Field(default=None, gt=0, description="处理人ID") @@ -59,15 +61,15 @@ class TicketUpdateSchema(BaseModel): @field_validator("status") @classmethod - def _validate_status(cls, v: str | None) -> str | None: + def _validate_status(cls, v: int | None) -> int | None: if v is None: return v - if v not in {"0", "1", "2", "3"}: + if v not in {0, 1, 2, 3}: raise ValueError("工单状态仅支持 0(待处理)、1(处理中)、2(已完成)、3(已关闭)") return v -class TicketOutSchema(BaseModel): +class TicketOutSchema(BaseSchema): """工单响应""" model_config = ConfigDict(from_attributes=True) @@ -77,13 +79,10 @@ class TicketOutSchema(BaseModel): ticket_content: str | None = None summary: str | None = None ticket_type: str - status: str + status: int images: str | None = None reply: str | None = None - description: str | None = None assigned_id: int | None = None - created_time: DateTimeStr | None = None - updated_time: DateTimeStr | None = None created_by: CommonSchema | None = None updated_by: CommonSchema | None = None assigned_by: CommonSchema | None = None @@ -93,16 +92,17 @@ class TicketBatchSchema(BaseModel): """批量更新工单""" ids: list[int] = Field(..., min_length=1, description="工单ID列表") - status: str = Field(..., max_length=10, description="状态(0:待处理 1:处理中 2:已完成 3:已关闭)") + status: int = Field(..., ge=0, le=3, description="状态(0:待处理 1:处理中 2:已完成 3:已关闭)") @field_validator("status") @classmethod - def _validate_status(cls, v: str) -> str: - if v not in {"0", "1", "2", "3"}: + def _validate_status(cls, v: int) -> int: + if v not in {0, 1, 2, 3}: raise ValueError("工单状态仅支持 0(待处理)、1(处理中)、2(已完成)、3(已关闭)") return v +@dataclass class TicketQueryParam: """工单查询参数""" @@ -115,12 +115,12 @@ class TicketQueryParam: assigned_id: int | None = None, ) -> None: if title: - self.title = ("like", title) + self.title = (QueueEnum.like.value, title) if ticket_type: - self.ticket_type = ("eq", ticket_type) + self.ticket_type = (QueueEnum.eq.value, ticket_type) if status: - self.status = ("eq", status) + self.status = (QueueEnum.eq.value, status) if created_id: - self.created_id = ("eq", created_id) + self.created_id = (QueueEnum.eq.value, created_id) if assigned_id: - self.assigned_id = ("eq", assigned_id) + self.assigned_id = (QueueEnum.eq.value, assigned_id) diff --git a/backend/app/api/v1/module_platform/ticket/service.py b/backend/app/api/v1/module_system/ticket/service.py similarity index 61% rename from backend/app/api/v1/module_platform/ticket/service.py rename to backend/app/api/v1/module_system/ticket/service.py index 3bfa0b14..e47d11e0 100644 --- a/backend/app/api/v1/module_platform/ticket/service.py +++ b/backend/app/api/v1/module_system/ticket/service.py @@ -1,4 +1,4 @@ -from app.api.v1.module_system.auth.schema import AuthSchema +from app.core.base_schema import AuthSchema from app.core.exceptions import CustomException from .crud import TicketCRUD @@ -11,17 +11,17 @@ from .schema import ( ) _TICKET_STATUS_TRANSITIONS = { - "0": {"1", "3"}, - "1": {"2", "3"}, - "2": {"3"}, - "3": {"0"}, + 0: {1, 3}, + 1: {2, 3}, + 2: {3}, + 3: {0}, } _TICKET_STATUS_LABELS = { - "0": "待处理", - "1": "处理中", - "2": "已完成", - "3": "已关闭", + 0: "待处理", + 1: "处理中", + 2: "已完成", + 3: "已关闭", } @@ -33,12 +33,12 @@ class TicketService: cls, auth: AuthSchema, ticket, - new_status: str, + new_status: int, ) -> None: """校验工单状态流转是否合法""" - old_status = str(ticket.status) if ticket.status is not None else "0" - old_label = _TICKET_STATUS_LABELS.get(old_status, old_status) - new_label = _TICKET_STATUS_LABELS.get(new_status, new_status) + old_status = ticket.status if ticket.status is not None else 0 + old_label = _TICKET_STATUS_LABELS.get(old_status, str(old_status)) + new_label = _TICKET_STATUS_LABELS.get(new_status, str(new_status)) if new_status not in _TICKET_STATUS_TRANSITIONS.get(old_status, set()): raise CustomException( @@ -49,22 +49,22 @@ class TicketService: is_creator = auth.user and ticket.created_id == auth.user.id is_assignee = auth.user and ticket.assigned_id == auth.user.id - if new_status == "0": + if new_status == 0: if not is_super: raise CustomException(msg="仅超管可以重新打开已关闭的工单") - elif old_status == "0" and new_status == "1": + elif old_status == 0 and new_status == 1: if not (is_super or is_creator or is_assignee): raise CustomException(msg="仅创建人、处理人或超管可以受理工单") - elif old_status == "0" and new_status == "3": + elif old_status == 0 and new_status == 3: if not (is_super or is_creator): raise CustomException(msg="仅创建人或超管可以取消工单") - elif old_status == "1" and new_status == "2": + elif old_status == 1 and new_status == 2: if not (is_super or is_assignee): raise CustomException(msg="仅处理人或超管可以将工单标记为已完成") - elif old_status == "1" and new_status == "3": + elif old_status == 1 and new_status == 3: if not (is_super or is_creator or is_assignee): raise CustomException(msg="仅创建人、处理人或超管可以关闭工单") - elif old_status == "2" and new_status == "3": + elif old_status == 2 and new_status == 3: if not (is_super or is_creator): raise CustomException(msg="仅创建人或超管可以确认关闭工单") @@ -77,7 +77,7 @@ class TicketService: search: TicketQueryParam | None = None, order_by: list | None = None, ) -> dict: - return await TicketCRUD(auth).page_crud( + return await TicketCRUD(auth).page( offset=(page_no - 1) * page_size, limit=page_size, order_by=order_by or [{"created_time": "desc"}], @@ -86,38 +86,55 @@ class TicketService: ) @classmethod - async def detail_service(cls, auth: AuthSchema, id: int) -> dict: - obj = await TicketCRUD(auth).get_by_id_crud(id=id) + async def detail_service(cls, auth: AuthSchema, id: int) -> TicketOutSchema: + obj = await TicketCRUD(auth).get(id=id) if not obj: raise CustomException(msg="工单不存在") - return TicketOutSchema.model_validate(obj).model_dump() + return TicketOutSchema.model_validate(obj) @classmethod - async def create_service(cls, auth: AuthSchema, data: TicketCreateSchema) -> dict: - obj = await TicketCRUD(auth).create_crud(data=data) + async def create_service(cls, auth: AuthSchema, data: TicketCreateSchema) -> TicketOutSchema: + obj = await TicketCRUD(auth).create(data=data) if not obj: raise CustomException(msg="创建工单失败") - return TicketOutSchema.model_validate(obj).model_dump() + return TicketOutSchema.model_validate(obj) @classmethod - async def update_service(cls, auth: AuthSchema, id: int, data: TicketUpdateSchema) -> dict: - obj = await TicketCRUD(auth).get_by_id_crud(id=id) + async def update_service(cls, auth: AuthSchema, id: int, data: TicketUpdateSchema) -> TicketOutSchema: + obj = await TicketCRUD(auth).get(id=id) if not obj: raise CustomException(msg="工单不存在") if data.status is not None: cls._validate_status_transition(auth, obj, data.status) - updated = await TicketCRUD(auth).update_crud(id=id, data=data) + # 校验 assigned_id：分配处理人时验证用户是否存在且属于同一租户 + if data.assigned_id is not None: + from sqlalchemy import select + + from app.api.v1.module_system.user.model import UserModel + + user_stmt = select(UserModel).where( + UserModel.id == data.assigned_id, + UserModel.is_deleted.is_(False), + ) + user_result = await auth.db.execute(user_stmt) + assigned_user = user_result.scalar_one_or_none() + if not assigned_user: + raise CustomException(msg="指定的处理人不存在") + if assigned_user.tenant_id != obj.tenant_id: + raise CustomException(msg="处理人必须与工单属于同一租户") + + updated = await TicketCRUD(auth).update(id=id, data=data) if not updated: raise CustomException(msg="更新失败") - return TicketOutSchema.model_validate(updated).model_dump() + return TicketOutSchema.model_validate(updated) @classmethod async def delete_service(cls, auth: AuthSchema, ids: list[int]) -> None: if not ids: raise CustomException(msg="删除对象不能为空") - await TicketCRUD(auth).delete_crud(ids=ids) + await TicketCRUD(auth).delete(ids=ids) @classmethod async def batch_service(cls, auth: AuthSchema, data: TicketBatchSchema) -> None: @@ -125,8 +142,10 @@ class TicketService: if not data.ids: raise CustomException(msg="请选择要操作的工单") + tickets = await TicketCRUD(auth).get_by_ids_crud(ids=data.ids) + ticket_map = {t.id: t for t in tickets} for tid in data.ids: - obj = await TicketCRUD(auth).get_by_id_crud(id=tid) + obj = ticket_map.get(tid) if not obj: raise CustomException(msg=f"工单[{tid}]不存在") cls._validate_status_transition(auth, obj, data.status) diff --git a/backend/app/api/v1/module_system/user/controller.py b/backend/app/api/v1/module_system/user/controller.py index 70d4d66a..ebe4c07a 100644 --- a/backend/app/api/v1/module_system/user/controller.py +++ b/backend/app/api/v1/module_system/user/controller.py @@ -5,12 +5,11 @@ from fastapi import APIRouter, Body, Depends, Path, UploadFile from fastapi.responses import JSONResponse, StreamingResponse from sqlalchemy.ext.asyncio import AsyncSession -from app.api.v1.module_system.auth.schema import AuthSchema from app.common.response import ResponseSchema, StreamResponse, SuccessResponse from app.core.base_params import PaginationQueryParam -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable, PageResultSchema from app.core.dependencies import AuthPermission, db_getter, get_current_user -from app.core.logger import log +from app.core.logger import logger from app.core.router_class import OperationLogRoute from app.utils.common_util import bytes2file_response @@ -27,13 +26,12 @@ from .schema import ( ) from .service import UserService -UserRouter = APIRouter(route_class=OperationLogRoute, prefix="/user", tags=["用户管理"]) +UserRouter = APIRouter(route_class=OperationLogRoute, prefix="/user", tags=["系统管理/用户管理"]) @UserRouter.get( "/current/info", summary="查询当前用户信息", - description="查询当前用户信息", response_model=ResponseSchema[UserOutSchema], ) async def get_current_user_info_controller( @@ -49,14 +47,12 @@ async def get_current_user_info_controller( - JSONResponse: 当前用户信息JSON响应 """ result_dict = await UserService.get_current_user_info_service(auth=auth) - log.info("获取当前用户信息成功") return SuccessResponse(data=result_dict, msg="获取当前用户信息成功") @UserRouter.put( "/current/info/update", summary="更新当前用户基本信息", - description="更新当前用户基本信息", response_model=ResponseSchema[UserOutSchema], ) async def update_current_user_info_controller( @@ -74,14 +70,12 @@ async def update_current_user_info_controller( - JSONResponse: 更新当前用户基本信息JSON响应 """ result_dict = await UserService.update_current_user_info_service(data=data, auth=auth) - log.info(f"更新当前用户基本信息成功: {result_dict}") return SuccessResponse(data=result_dict, msg="更新当前用户基本信息成功") @UserRouter.put( "/password/change", summary="修改当前用户密码", - description="修改当前用户密码", response_model=ResponseSchema[UserOutSchema], ) async def change_current_user_password_controller( @@ -99,20 +93,18 @@ async def change_current_user_password_controller( - JSONResponse: 修改密码JSON响应 """ result_dict = await UserService.change_user_password_service(data=data, auth=auth) - log.info(f"修改密码成功: {result_dict}") return SuccessResponse(data=result_dict, msg="修改密码成功, 请重新登录") @UserRouter.put( "/password/reset/{id}", summary="重置用户密码", - description="重置指定用户密码", response_model=ResponseSchema[UserOutSchema], ) async def reset_password_controller( id: Annotated[int, Path(description="用户ID")], data: ResetPasswordSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:user:update"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:user:update']))], ) -> JSONResponse: """ 重置密码 @@ -127,14 +119,12 @@ async def reset_password_controller( """ data.id = id result_dict = await UserService.reset_user_password_service(data=data, auth=auth) - log.info(f"重置密码成功: {result_dict}") return SuccessResponse(data=result_dict, msg="重置密码成功") @UserRouter.post( "/register", summary="注册用户", - description="注册用户", response_model=ResponseSchema[UserOutSchema], ) async def register_user_controller( @@ -153,14 +143,13 @@ async def register_user_controller( """ auth = AuthSchema(db=db) user_register_result = await UserService.register_user_service(data=data, auth=auth) - log.info(f"{data.username} 注册用户成功: {user_register_result}") + logger.info(f"{data.username} 注册用户成功: {user_register_result}") return SuccessResponse(data=user_register_result, msg="注册用户成功") @UserRouter.post( "/password/forget", summary="忘记密码", - description="忘记密码找回", response_model=ResponseSchema[UserOutSchema], ) async def forget_password_controller( @@ -179,20 +168,19 @@ async def forget_password_controller( """ auth = AuthSchema(db=db) user_forget_password_result = await UserService.forget_password_service(data=data, auth=auth) - log.info(f"{data.username} 重置密码成功: {user_forget_password_result}") + logger.info(f"{data.username} 重置密码成功: {user_forget_password_result}") return SuccessResponse(data=user_forget_password_result, msg="重置密码成功") @UserRouter.get( "/list", summary="查询用户", - description="查询用户", - response_model=ResponseSchema[list[UserOutSchema]], + response_model=ResponseSchema[PageResultSchema[UserOutSchema]], ) async def get_obj_list_controller( page: Annotated[PaginationQueryParam, Depends()], search: Annotated[UserQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:user:query"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:user:query']))], ) -> JSONResponse: """ 查询用户 @@ -212,19 +200,17 @@ async def get_obj_list_controller( search=search, order_by=page.order_by, ) - log.info("查询用户成功") return SuccessResponse(data=result_dict, msg="查询用户成功") @UserRouter.get( "/detail/{id}", summary="查询用户详情", - description="查询用户详情", response_model=ResponseSchema[UserOutSchema], ) async def get_obj_detail_controller( id: Annotated[int, Path(description="用户ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:user:detail"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:user:detail']))], ) -> JSONResponse: """ 查询用户详情 @@ -237,19 +223,17 @@ async def get_obj_detail_controller( - JSONResponse: 用户详情JSON响应 """ result_dict = await UserService.get_detail_by_id_service(id=id, auth=auth) - log.info(f"获取用户详情成功 {id}") return SuccessResponse(data=result_dict, msg="获取用户详情成功") @UserRouter.post( "/create", summary="创建用户", - description="创建用户", response_model=ResponseSchema[UserOutSchema], ) async def create_obj_controller( data: UserCreateSchema, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:user:create"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:user:create']))], ) -> JSONResponse: """ 创建用户 @@ -266,20 +250,18 @@ async def create_obj_controller( - JSONResponse: 创建用户JSON响应 """ result_dict = await UserService.create_user_service(data=data, auth=auth) - log.info(f"创建用户成功: {result_dict}") return SuccessResponse(data=result_dict, msg="创建用户成功") @UserRouter.put( "/update/{id}", summary="修改用户", - description="修改用户", response_model=ResponseSchema[UserOutSchema], ) async def update_obj_controller( data: UserUpdateSchema, id: Annotated[int, Path(description="用户ID")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:user:update"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:user:update']))], ) -> JSONResponse: """ 修改用户 @@ -293,19 +275,17 @@ async def update_obj_controller( - JSONResponse: 修改用户JSON响应 """ result_dict = await UserService.update_user_service(id=id, data=data, auth=auth) - log.info(f"修改用户成功: {result_dict}") return SuccessResponse(data=result_dict, msg="修改用户成功") @UserRouter.delete( "/delete", summary="删除用户", - description="删除用户", response_model=ResponseSchema[None], ) async def delete_obj_controller( ids: Annotated[list[int], Body(description="ID列表")], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:user:delete"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:user:delete']))], ) -> JSONResponse: """ 删除用户 @@ -318,19 +298,17 @@ async def delete_obj_controller( - JSONResponse: 删除用户JSON响应 """ await UserService.delete_user_service(ids=ids, auth=auth) - log.info(f"删除用户成功: {ids}") return SuccessResponse(msg="删除用户成功") @UserRouter.patch( "/status/batch", summary="批量修改用户状态", - description="批量修改用户状态", response_model=ResponseSchema[None], ) async def batch_set_available_obj_controller( data: BatchSetAvailable, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:user:patch"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:user:patch']))], ) -> JSONResponse: """ 批量修改用户状态 @@ -343,16 +321,14 @@ async def batch_set_available_obj_controller( - JSONResponse: 批量修改用户状态JSON响应 """ await UserService.set_user_available_service(data=data, auth=auth) - log.info(f"批量修改用户状态成功: {data.ids}") return SuccessResponse(msg="批量修改用户状态成功") @UserRouter.get( "/import/template", summary="获取用户导入模板", - description="获取用户导入模板", response_model=ResponseSchema[None], - dependencies=[Depends(AuthPermission(["module_system:user:download"]))], + dependencies=[Depends(AuthPermission(['module_system:user:download']))], ) async def export_obj_template_controller() -> StreamingResponse: """ @@ -362,7 +338,6 @@ async def export_obj_template_controller() -> StreamingResponse: - StreamingResponse: 用户导入模板流响应 """ user_import_template_result = await UserService.get_import_template_user_service() - log.info("获取用户导入模板成功") return StreamResponse( data=bytes2file_response(user_import_template_result), @@ -377,13 +352,12 @@ async def export_obj_template_controller() -> StreamingResponse: @UserRouter.get( "/export", summary="导出用户", - description="导出用户列表", response_model=ResponseSchema[None], ) async def export_obj_list_controller( page: Annotated[PaginationQueryParam, Depends()], search: Annotated[UserQueryParam, Depends()], - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:user:export"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:user:export']))], ) -> StreamingResponse: """ 导出用户 @@ -400,7 +374,6 @@ async def export_obj_list_controller( auth=auth, search=search, order_by=page.order_by ) user_export_result = await UserService.export_user_list_service(user_list) - log.info("导出用户成功") return StreamResponse( data=bytes2file_response(user_export_result), @@ -412,12 +385,11 @@ async def export_obj_list_controller( @UserRouter.post( "/import/data", summary="导入用户", - description="导入用户", response_model=ResponseSchema[None], ) async def import_obj_list_controller( file: UploadFile, - auth: Annotated[AuthSchema, Depends(AuthPermission(["module_system:user:import"]))], + auth: Annotated[AuthSchema, Depends(AuthPermission(['module_system:user:import']))], ) -> JSONResponse: """ 导入用户 @@ -432,5 +404,4 @@ async def import_obj_list_controller( batch_import_result = await UserService.batch_import_user_service( file=file, auth=auth, update_support=True ) - log.info(f"导入用户成功: {batch_import_result}") return SuccessResponse(data=batch_import_result, msg="导入用户成功") diff --git a/backend/app/api/v1/module_system/user/crud.py b/backend/app/api/v1/module_system/user/crud.py index 588df65e..b684d14c 100644 --- a/backend/app/api/v1/module_system/user/crud.py +++ b/backend/app/api/v1/module_system/user/crud.py @@ -1,16 +1,13 @@ -from collections.abc import Sequence from datetime import datetime -from typing import Any -from app.api.v1.module_system.auth.schema import AuthSchema from app.api.v1.module_system.position.crud import PositionCRUD from app.api.v1.module_system.role.crud import RoleCRUD from app.core.base_crud import CRUDBase +from app.core.base_schema import AuthSchema from .model import UserModel from .schema import ( UserCreateSchema, - UserForgetPasswordSchema, UserUpdateSchema, ) @@ -28,112 +25,18 @@ class UserCRUD(CRUDBase[UserModel, UserCreateSchema, UserUpdateSchema]): 返回: - None """ - self.auth = auth super().__init__(model=UserModel, auth=auth) - async def get_by_id_crud( - self, id: int, preload: list[str | Any] | None = None - ) -> UserModel | None: - """ - 根据id获取用户信息 - - 参数: - - id (int): 用户ID - - preload (list[str | Any] | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - UserModel | None: 用户信息,如果不存在则为None - """ - return await self.get( - preload=preload, - id=id, - ) - - async def get_by_username_crud( - self, username: str, preload: list[str | Any] | None = None - ) -> UserModel | None: - """ - 根据用户名获取用户信息 - - 参数: - - username (str): 用户名 - - preload (list[str | Any] | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - UserModel | None: 用户信息,如果不存在则为None - """ - return await self.get( - preload=preload, - username=username, - ) - - async def get_by_mobile_crud( - self, mobile: str, preload: list[str | Any] | None = None - ) -> UserModel | None: - """ - 根据手机号获取用户信息 - - 参数: - - mobile (str): 手机号 - - preload (list[str | Any] | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - UserModel | None: 用户信息,如果不存在则为None - """ - return await self.get( - preload=preload, - mobile=mobile, - ) - - async def get_list_crud( - self, - search: dict | None = None, - order_by: list[dict[str, str]] | None = None, - preload: list[str | Any] | None = None, - ) -> Sequence[UserModel]: - """ - 获取用户列表 - - 参数: - - search (dict | None): 查询参数对象。 - - order_by (list[dict[str, str]] | None): 排序参数列表。 - - preload (list[str | Any] | None): 预加载关系，未提供时使用模型默认项 - - 返回: - - Sequence[UserModel]: 用户列表 - """ - return await self.list( - search=search, - order_by=order_by, - preload=preload, - ) - - async def update_last_login_crud(self, id: int) -> UserModel | None: + async def update_last_login(self, id: int) -> None: """ 更新用户最后登录时间 参数: - id (int): 用户ID - - 返回: - - UserModel | None: 更新后的用户信息 """ - return await self.update(id=id, data={"last_login": datetime.now()}) + await self.set([id], last_login=datetime.now()) - async def set_available_crud(self, ids: list[int], status: str) -> None: - """ - 批量设置用户可用状态 - - 参数: - - ids (list[int]): 用户ID列表 - - status (str): 可用状态（与表字段一致，如 "0"/"1"） - - 返回: - - None - """ - await self.set(ids=ids, status=status) - - async def set_user_roles_crud(self, user_ids: list[int], role_ids: list[int]) -> None: + async def set_user_roles(self, user_ids: list[int], role_ids: list[int]) -> None: """ 批量设置用户角色 @@ -146,7 +49,7 @@ class UserCRUD(CRUDBase[UserModel, UserCreateSchema, UserUpdateSchema]): """ user_objs = await self.list(search={"id": ("in", user_ids)}) if role_ids: - role_objs = await RoleCRUD(self.auth).get_list_crud(search={"id": ("in", role_ids)}) + role_objs = await RoleCRUD(self.auth).list(search={"id": ("in", role_ids)}) else: role_objs = [] @@ -156,7 +59,7 @@ class UserCRUD(CRUDBase[UserModel, UserCreateSchema, UserUpdateSchema]): relationship.extend(role_objs) await self.auth.db.flush() - async def set_user_positions_crud(self, user_ids: list[int], position_ids: list[int]) -> None: + async def set_user_positions(self, user_ids: list[int], position_ids: list[int]) -> None: """ 批量设置用户岗位 @@ -169,7 +72,7 @@ class UserCRUD(CRUDBase[UserModel, UserCreateSchema, UserUpdateSchema]): """ user_objs = await self.list(search={"id": ("in", user_ids)}) if position_ids: - position_objs = await PositionCRUD(self.auth).get_list_crud( + position_objs = await PositionCRUD(self.auth).list( search={"id": ("in", position_ids)} ) else: @@ -181,7 +84,7 @@ class UserCRUD(CRUDBase[UserModel, UserCreateSchema, UserUpdateSchema]): relationship.extend(position_objs) await self.auth.db.flush() - async def change_password_crud(self, id: int, password_hash: str) -> UserModel: + async def change_password(self, id: int, password_hash: str) -> UserModel: """ 修改用户密码 @@ -194,27 +97,6 @@ class UserCRUD(CRUDBase[UserModel, UserCreateSchema, UserUpdateSchema]): """ return await self.update(id=id, data=UserUpdateSchema(password=password_hash)) - async def forget_password_crud(self, id: int, password_hash: str) -> UserModel: - """ - 重置密码 - - 参数: - - id (int): 用户ID - - password_hash (str): 密码哈希值 - - 返回: - - UserModel: 更新后的用户信息 - """ - return await self.update(id=id, data=UserUpdateSchema(password=password_hash)) - - async def register_user_crud(self, data: UserForgetPasswordSchema) -> UserModel: - """ - 用户注册 - - 参数: - - data (UserForgetPasswordSchema): 用户注册信息 - - 返回: - - UserModel: 注册成功的用户信息 - """ - return await self.create(data=UserCreateSchema(**data.model_dump())) + async def forget_password(self, id: int, password_hash: str) -> UserModel: + """重置密码（与 change_password 逻辑相同）""" + return await self.change_password(id=id, password_hash=password_hash) diff --git a/backend/app/api/v1/module_system/user/model.py b/backend/app/api/v1/module_system/user/model.py index f3fb2ad4..28b15f58 100644 --- a/backend/app/api/v1/module_system/user/model.py +++ b/backend/app/api/v1/module_system/user/model.py @@ -5,6 +5,7 @@ from sqlalchemy import Boolean, DateTime, ForeignKey, Integer, String, UniqueCon from sqlalchemy.orm import Mapped, mapped_column, relationship from app.core.base_model import MappedBase, ModelMixin, TenantMixin, UserMixin +from app.core.base_schema import AuthSchema if TYPE_CHECKING: from app.api.v1.module_platform.tenant.model import TenantModel @@ -69,7 +70,7 @@ class UserModel(ModelMixin, TenantMixin, UserMixin): __tablename__: str = "sys_user" __table_args__ = (UniqueConstraint("tenant_id", "username"), {"comment": "用户表"}) __loader_options__: list[str] = [ - "tenant", + "tenant_by", "dept", "roles", "positions", @@ -144,7 +145,5 @@ class UserModel(ModelMixin, TenantMixin, UserMixin): ) -# 修复 Pydantic 循环引用问题 -from app.core.auth_schema import AuthSchema - +# 修复 Pydantic 循环引用问题：UserModel 定义完成后重建 AuthSchema AuthSchema.model_rebuild() diff --git a/backend/app/api/v1/module_system/user/schema.py b/backend/app/api/v1/module_system/user/schema.py index a93635b4..7cbdfc1e 100644 --- a/backend/app/api/v1/module_system/user/schema.py +++ b/backend/app/api/v1/module_system/user/schema.py @@ -10,7 +10,7 @@ from pydantic import ( model_validator, ) -from app.api.v1.module_system.menu.schema import MenuOutSchema +from app.api.v1.module_platform.menu.schema import MenuOutSchema from app.api.v1.module_system.role.schema import RoleOutSchema from app.common.enums import QueueEnum from app.core.base_schema import BaseSchema, CommonSchema, TenantBySchema, UserBySchema @@ -193,9 +193,9 @@ class UserCreateSchema(CurrentUserUpdateSchema): model_config = ConfigDict(from_attributes=True) - username: str | None = Field(default=None, min_length=3, max_length=32, description="用户名") + username: str | None = Field(default=None, max_length=32, description="用户名") password: str | None = Field(default=None, min_length=6, max_length=128, description="密码") - status: str = Field(default="0", max_length=1, description="状态(0:正常 1:禁用)") + status: int = Field(default=0, ge=0, le=1, description="状态(0:正常 1:禁用)") description: str | None = Field(default=None, max_length=255, description="备注") is_superuser: bool | None = Field(default=False, description="是否超管") dept_id: int | None = Field(default=None, description="部门ID") @@ -205,22 +205,22 @@ class UserCreateSchema(CurrentUserUpdateSchema): @field_validator("status") @classmethod - def validate_status(cls, value: str): + def validate_status(cls, value: int): """校验状态：仅支持 0(正常)、1(禁用)""" - if value not in {"0", "1"}: + if value not in {0, 1}: raise ValueError("状态仅支持 0(正常) 或 1(禁用)") return value @field_validator("username") @classmethod def validate_username(cls, value: str | None): - """校验账号：字母开头，3-32 位""" + """校验账号：字母开头，2-32 位""" if not value: return value v = value.strip() import re - if not re.match(r"^[A-Za-z][A-Za-z0-9_.-]{2,31}$", v): - raise ValueError("账号需以字母开头，3-32 位，仅允许字母、数字、_ . -") + if not re.match(r"^[A-Za-z][A-Za-z0-9_.-]{1,31}$", v): + raise ValueError("账号需以字母开头，2-32 位，仅允许字母、数字、_ . -") return v @field_validator("password") @@ -247,6 +247,8 @@ class UserOutSchema(UserUpdateSchema, BaseSchema, UserBySchema, TenantBySchema): model_config = ConfigDict(arbitrary_types_allowed=True, from_attributes=True) + username: str | None = Field(default=None, max_length=32, description="用户名") + tenant_id: int | None = Field( default=None, exclude=True, diff --git a/backend/app/api/v1/module_system/user/service.py b/backend/app/api/v1/module_system/user/service.py index 3b4dc546..3e48ad75 100644 --- a/backend/app/api/v1/module_system/user/service.py +++ b/backend/app/api/v1/module_system/user/service.py @@ -4,15 +4,14 @@ from typing import Any import pandas as pd from fastapi import UploadFile -from app.api.v1.module_system.auth.schema import AuthSchema +from app.api.v1.module_platform.menu.crud import MenuCRUD +from app.api.v1.module_platform.menu.schema import MenuOutSchema from app.api.v1.module_system.dept.crud import DeptCRUD -from app.api.v1.module_system.menu.crud import MenuCRUD -from app.api.v1.module_system.menu.schema import MenuOutSchema from app.api.v1.module_system.position.crud import PositionCRUD from app.api.v1.module_system.role.crud import RoleCRUD -from app.core.base_schema import BatchSetAvailable +from app.core.base_schema import AuthSchema, BatchSetAvailable from app.core.exceptions import CustomException -from app.core.logger import log +from app.core.logger import logger from app.utils.common_util import traversal_to_tree from app.utils.excel_util import ExcelUtil from app.utils.hash_bcrpy_util import PwdUtil @@ -35,7 +34,7 @@ class UserService: """用户模块服务层""" @classmethod - async def get_detail_by_id_service(cls, auth: AuthSchema, id: int) -> dict: + async def get_detail_by_id_service(cls, auth: AuthSchema, id: int) -> UserOutSchema: """ 根据ID获取用户详情 @@ -46,26 +45,20 @@ class UserService: 返回: - dict: 用户详情字典 """ - user = await UserCRUD(auth).get_by_id_crud(id=id) + user = await UserCRUD(auth).get(id=id) if not user: raise CustomException(msg="用户不存在") + result = UserOutSchema.model_validate(user) # 如果用户绑定了部门,则获取部门名称 if user.dept_id: - dept = await DeptCRUD(auth).get_by_id_crud(id=user.dept_id) - UserOutSchema.dept_name = dept.name if dept else None - else: - UserOutSchema.dept_name = None + dept = await DeptCRUD(auth).get(id=user.dept_id) + result.dept_name = dept.name if dept else None - return UserOutSchema.model_validate(user).model_dump() + return result @classmethod - async def get_user_list_service( - cls, - auth: AuthSchema, - search: UserQueryParam | None = None, - order_by: list[dict[str, str]] | None = None, - ) -> list[dict]: + async def get_user_list_service(cls, auth: AuthSchema, search: UserQueryParam | None = None, order_by: list[dict[str, str]] | None = None) -> list[UserOutSchema]: """ 获取用户列表 @@ -77,23 +70,16 @@ class UserService: 返回: - list[dict]: 用户详情字典列表 """ - user_list = await UserCRUD(auth).get_list_crud(search=search.__dict__, order_by=order_by) + user_list = await UserCRUD(auth).list(search=search.__dict__ if search else {}, order_by=order_by) user_dict_list = [] for user in user_list: - user_dict = UserOutSchema.model_validate(user).model_dump() + user_dict = UserOutSchema.model_validate(user) user_dict_list.append(user_dict) return user_dict_list @classmethod - async def get_user_page_service( - cls, - auth: AuthSchema, - page_no: int, - page_size: int, - search: UserQueryParam | None = None, - order_by: list[dict[str, str]] | None = None, - ) -> dict: + async def get_user_page_service(cls, auth: AuthSchema, page_no: int, page_size: int, search: UserQueryParam | None = None, order_by: list[dict[str, str]] | None = None) -> dict: """ 分页查询用户（数据库 OFFSET/LIMIT）。 @@ -117,7 +103,7 @@ class UserService: ) @classmethod - async def create_user_service(cls, data: UserCreateSchema, auth: AuthSchema) -> dict: + async def create_user_service(cls, data: UserCreateSchema, auth: AuthSchema) -> UserOutSchema: """ 创建用户 @@ -134,13 +120,13 @@ class UserService: if data.is_superuser: raise CustomException(msg="不允许创建超级管理员") # 检查用户名是否存在 - user = await UserCRUD(auth).get_by_username_crud(username=data.username) + user = await UserCRUD(auth).get(username=data.username) if user: raise CustomException(msg="已存在相同用户名称的账号") # 检查部门是否存在 if data.dept_id: - dept = await DeptCRUD(auth).get_by_id_crud(id=data.dept_id) + dept = await DeptCRUD(auth).get(id=data.dept_id) if not dept: raise CustomException(msg="部门不存在") @@ -156,18 +142,18 @@ class UserService: new_user = await UserCRUD(auth).create(data=user_dict) # 设置角色 if data.role_ids and len(data.role_ids) > 0: - await UserCRUD(auth).set_user_roles_crud(user_ids=[new_user.id], role_ids=data.role_ids) + await UserCRUD(auth).set_user_roles(user_ids=[new_user.id], role_ids=data.role_ids) # 设置岗位 if data.position_ids and len(data.position_ids) > 0: - await UserCRUD(auth).set_user_positions_crud( + await UserCRUD(auth).set_user_positions( user_ids=[new_user.id], position_ids=data.position_ids ) - new_user_dict = UserOutSchema.model_validate(new_user).model_dump() + new_user_dict = UserOutSchema.model_validate(new_user) return new_user_dict @classmethod - async def update_user_service(cls, id: int, data: UserUpdateSchema, auth: AuthSchema) -> dict: + async def update_user_service(cls, id: int, data: UserUpdateSchema, auth: AuthSchema) -> UserOutSchema: """ 更新用户 @@ -183,7 +169,7 @@ class UserService: raise CustomException(msg="账号不能为空") # 检查用户是否存在 - user = await UserCRUD(auth).get_by_id_crud(id=id) + user = await UserCRUD(auth).get(id=id) if not user: raise CustomException(msg="用户不存在") @@ -192,12 +178,12 @@ class UserService: raise CustomException(msg="超级管理员不允许修改") # 检查用户名是否重复 - exist_user = await UserCRUD(auth).get_by_username_crud(username=data.username) + exist_user = await UserCRUD(auth).get(username=data.username) if exist_user and exist_user.id != id: raise CustomException(msg="已存在相同的账号") # 新增：检查手机号是否重复 if data.mobile: - exist_mobile_user = await UserCRUD(auth).get_by_mobile_crud(mobile=data.mobile) + exist_mobile_user = await UserCRUD(auth).get(mobile=data.mobile) if exist_mobile_user and exist_mobile_user.id != id: raise CustomException(msg="更新失败，手机号已存在") # 新增：检查邮箱是否重复 @@ -207,10 +193,10 @@ class UserService: raise CustomException(msg="更新失败，邮箱已存在") # 检查部门是否存在且可用 if data.dept_id: - dept = await DeptCRUD(auth).get_by_id_crud(id=data.dept_id) + dept = await DeptCRUD(auth).get(id=data.dept_id) if not dept: raise CustomException(msg="部门不存在") - if dept.status == "1": + if dept.status == 1: raise CustomException(msg="部门已被禁用") # 更新用户 - 排除不应被修改的字段, 更新不更新密码 @@ -223,27 +209,27 @@ class UserService: # 更新角色和岗位 if data.role_ids and len(data.role_ids) > 0: # 检查角色是否都存在且可用 - roles = await RoleCRUD(auth).get_list_crud(search={"id": ("in", data.role_ids)}) + roles = await RoleCRUD(auth).list(search={"id": ("in", data.role_ids)}) if len(roles) != len(data.role_ids): raise CustomException(msg="部分角色不存在") - if not all(role.status for role in roles): + if not all(role.status == 0 for role in roles): raise CustomException(msg="部分角色已被禁用") - await UserCRUD(auth).set_user_roles_crud(user_ids=[id], role_ids=data.role_ids) + await UserCRUD(auth).set_user_roles(user_ids=[id], role_ids=data.role_ids) if data.position_ids and len(data.position_ids) > 0: # 检查岗位是否都存在且可用 - positions = await PositionCRUD(auth).get_list_crud( + positions = await PositionCRUD(auth).list( search={"id": ("in", data.position_ids)} ) if len(positions) != len(data.position_ids): raise CustomException(msg="部分岗位不存在") - if not all(position.status for position in positions): + if not all(position.status == 0 for position in positions): raise CustomException(msg="部分岗位已被禁用") - await UserCRUD(auth).set_user_positions_crud( + await UserCRUD(auth).set_user_positions( user_ids=[id], position_ids=data.position_ids ) - user_dict = UserOutSchema.model_validate(new_user).model_dump() + user_dict = UserOutSchema.model_validate(new_user) return user_dict @classmethod @@ -260,27 +246,30 @@ class UserService: """ if len(ids) < 1: raise CustomException(msg="删除失败，删除对象不能为空") - for id in ids: - user = await UserCRUD(auth).get_by_id_crud(id=id) + # 批量查询所有待删除用户 + users = await UserCRUD(auth).list(search={"id": ("in", ids)}) + user_map = {u.id: u for u in users} + for uid in ids: + user = user_map.get(uid) if not user: raise CustomException(msg="用户不存在") if user.is_superuser: raise CustomException(msg="超级管理员不能删除") - if user.status == "0": + if user.status == 0: raise CustomException(msg="用户已启用,不能删除") - if auth.user and auth.user.id == id: + if auth.user and auth.user.id == uid: raise CustomException(msg="不能删除当前登陆用户") # 删除用户角色关联数据 - await UserCRUD(auth).set_user_roles_crud(user_ids=ids, role_ids=[]) + await UserCRUD(auth).set_user_roles(user_ids=ids, role_ids=[]) # 删除用户岗位关联数据 - await UserCRUD(auth).set_user_positions_crud(user_ids=ids, position_ids=[]) + await UserCRUD(auth).set_user_positions(user_ids=ids, position_ids=[]) # 删除用户 await UserCRUD(auth).delete(ids=ids) @classmethod - async def get_current_user_info_service(cls, auth: AuthSchema) -> dict: + async def get_current_user_info_service(cls, auth: AuthSchema) -> UserOutSchema: """ 获取当前用户信息 @@ -293,46 +282,45 @@ class UserService: # 获取用户基本信息 if not auth.user or not auth.user.id: raise CustomException(msg="用户不存在") - user = await UserCRUD(auth).get_by_id_crud(id=auth.user.id) + user = await UserCRUD(auth).get(id=auth.user.id) + user_dict = UserOutSchema.model_validate(user) # 获取部门名称 if user and user.dept: - UserOutSchema.dept_name = user.dept.name - user_dict = UserOutSchema.model_validate(user).model_dump() + user_dict.dept_name = user.dept.name # 获取菜单权限（PC 管理端侧栏：仅 client=pc） _pc_only = {"client": "pc"} if auth.user and auth.user.is_superuser: - # 使用树形结构查询，预加载children关系 - menu_all = await MenuCRUD(auth).get_tree_list_crud( - search={"type": ("in", [1, 2, 4]), "status": "0", **_pc_only}, + # 使用树形结构查询，预加载children关系（含 type=3 按钮，供前端权限列表使用） + menu_all = await MenuCRUD(auth).get_tree_list( + search={"type": ("in", [1, 2, 3, 4]), "status": "0", **_pc_only}, order_by=[{"order": "asc"}], ) - menus = [MenuOutSchema.model_validate(menu).model_dump() for menu in menu_all] + menus = [MenuOutSchema.model_validate(menu) for menu in menu_all] else: - # 收集用户所有角色的菜单 ID（仅 PC 端菜单参与动态路由） + # 收集用户所有角色的菜单 ID（含按钮，供前端权限列表使用） menu_ids = { menu.id for role in auth.user.roles or [] for menu in role.menus - if menu.status == "0" - and menu.type in [1, 2, 4] + if menu.status == 0 and getattr(menu, "client", "pc") == "pc" } # 租户菜单约束：非超管用户只能看到租户菜单权限内的菜单 if menu_ids and auth.tenant_id: - from app.api.v1.module_platform.tenant.service import TenantService + from app.api.v1.module_platform.package.service import PackageService - allowed_ids = await TenantService.get_tenant_menu_ids(auth, auth.tenant_id) + allowed_ids = await PackageService.get_tenant_available_menu_ids(auth, auth.tenant_id) allowed_set = set(allowed_ids) menu_ids = menu_ids & allowed_set # 使用树形结构查询，预加载children关系 menus = ( [ - MenuOutSchema.model_validate(menu).model_dump() - for menu in await MenuCRUD(auth).get_tree_list_crud( + MenuOutSchema.model_validate(menu) + for menu in await MenuCRUD(auth).get_tree_list( search={"id": ("in", list(menu_ids)), **_pc_only}, order_by=[{"order": "asc"}], ) @@ -340,13 +328,11 @@ class UserService: if menu_ids else [] ) - user_dict["menus"] = traversal_to_tree(menus) + user_dict.menus = traversal_to_tree([menu.model_dump() for menu in menus]) return user_dict @classmethod - async def update_current_user_info_service( - cls, auth: AuthSchema, data: CurrentUserUpdateSchema - ) -> dict: + async def update_current_user_info_service(cls, auth: AuthSchema, data: CurrentUserUpdateSchema) -> UserOutSchema: """ 更新当前用户信息 @@ -359,14 +345,14 @@ class UserService: """ if not auth.user or not auth.user.id: raise CustomException(msg="用户不存在") - user = await UserCRUD(auth).get_by_id_crud(id=auth.user.id) + user = await UserCRUD(auth).get(id=auth.user.id) if not user: raise CustomException(msg="用户不存在") if user.is_superuser: raise CustomException(msg="超级管理员不能修改个人信息") # 新增：检查手机号是否重复 if data.mobile: - exist_mobile_user = await UserCRUD(auth).get_by_mobile_crud(mobile=data.mobile) + exist_mobile_user = await UserCRUD(auth).get(mobile=data.mobile) if exist_mobile_user and exist_mobile_user.id != auth.user.id: raise CustomException(msg="更新失败，手机号已存在") # 新增：检查邮箱是否重复 @@ -376,7 +362,7 @@ class UserService: raise CustomException(msg="更新失败，邮箱已存在") user_update_data = UserUpdateSchema(**data.model_dump()) new_user = await UserCRUD(auth).update(id=auth.user.id, data=user_update_data) - return UserOutSchema.model_validate(new_user).model_dump() + return UserOutSchema.model_validate(new_user) @classmethod async def set_user_available_service(cls, auth: AuthSchema, data: BatchSetAvailable) -> None: @@ -391,17 +377,15 @@ class UserService: - None """ for id in data.ids: - user = await UserCRUD(auth).get_by_id_crud(id=id) + user = await UserCRUD(auth).get(id=id) if not user: raise CustomException(msg=f"用户ID {id} 不存在") if user.is_superuser: raise CustomException(msg="超级管理员状态不能修改") - await UserCRUD(auth).set_available_crud(ids=data.ids, status=data.status) + await UserCRUD(auth).set(ids=data.ids, status=data.status) @classmethod - async def change_user_password_service( - cls, auth: AuthSchema, data: UserChangePasswordSchema - ) -> dict: + async def change_user_password_service(cls, auth: AuthSchema, data: UserChangePasswordSchema) -> UserOutSchema: """ 修改用户密码 @@ -418,7 +402,7 @@ class UserService: raise CustomException(msg="密码不能为空") # 验证原密码 - user = await UserCRUD(auth).get_by_id_crud(id=auth.user.id) + user = await UserCRUD(auth).get(id=auth.user.id) if not user: raise CustomException(msg="用户不存在") if not PwdUtil.verify_password( @@ -428,13 +412,13 @@ class UserService: # 更新密码 new_password_hash = PwdUtil.set_password_hash(password=data.new_password) - new_user = await UserCRUD(auth).change_password_crud( + new_user = await UserCRUD(auth).change_password( id=user.id, password_hash=new_password_hash ) - return UserOutSchema.model_validate(new_user).model_dump() + return UserOutSchema.model_validate(new_user) @classmethod - async def reset_user_password_service(cls, auth: AuthSchema, data: ResetPasswordSchema) -> dict: + async def reset_user_password_service(cls, auth: AuthSchema, data: ResetPasswordSchema) -> UserOutSchema: """ 重置用户密码 @@ -449,7 +433,7 @@ class UserService: raise CustomException(msg="密码不能为空") # 验证用户 - user = await UserCRUD(auth).get_by_id_crud(id=data.id) + user = await UserCRUD(auth).get(id=data.id) if not user: raise CustomException(msg="用户不存在") @@ -459,13 +443,13 @@ class UserService: # 更新密码 new_password_hash = PwdUtil.set_password_hash(password=data.password) - new_user = await UserCRUD(auth).change_password_crud( + new_user = await UserCRUD(auth).change_password( id=data.id, password_hash=new_password_hash ) - return UserOutSchema.model_validate(new_user).model_dump() + return UserOutSchema.model_validate(new_user) @classmethod - async def register_user_service(cls, auth: AuthSchema, data: UserRegisterSchema) -> dict: + async def register_user_service(cls, auth: AuthSchema, data: UserRegisterSchema) -> UserOutSchema: """ 用户注册 @@ -477,7 +461,7 @@ class UserService: - Dict: 注册后的用户详情字典 """ # 检查用户名是否存在 - username_ok = await UserCRUD(auth).get_by_username_crud(username=data.username) + username_ok = await UserCRUD(auth).get(username=data.username) if username_ok: raise CustomException(msg="账号已存在") @@ -491,13 +475,11 @@ class UserService: result = await UserCRUD(auth).create(data=create_dict) if data.role_ids: - await UserCRUD(auth).set_user_roles_crud(user_ids=[result.id], role_ids=data.role_ids) - return UserOutSchema.model_validate(result).model_dump() + await UserCRUD(auth).set_user_roles(user_ids=[result.id], role_ids=data.role_ids) + return UserOutSchema.model_validate(result) @classmethod - async def forget_password_service( - cls, auth: AuthSchema, data: UserForgetPasswordSchema - ) -> dict: + async def forget_password_service(cls, auth: AuthSchema, data: UserForgetPasswordSchema) -> UserOutSchema: """ 用户忘记密码 @@ -508,26 +490,28 @@ class UserService: 返回: - Dict: 更新后的当前用户详情字典 """ - user = await UserCRUD(auth).get_by_username_crud(username=data.username) + user = await UserCRUD(auth).get(username=data.username) if not user: raise CustomException(msg="用户不存在") - if user.status == "1": + if user.status == 1: raise CustomException(msg="用户已停用") # 检查是否是超级管理员 if user.is_superuser: raise CustomException(msg="超级管理员密码不能重置") + # 校验手机号是否匹配 + if data.mobile and user.mobile != data.mobile: + raise CustomException(msg="手机号不匹配") + new_password_hash = PwdUtil.set_password_hash(password=data.new_password) - new_user = await UserCRUD(auth).forget_password_crud( + new_user = await UserCRUD(auth).forget_password( id=user.id, password_hash=new_password_hash ) - return UserOutSchema.model_validate(new_user).model_dump() + return UserOutSchema.model_validate(new_user) @classmethod - async def batch_import_user_service( - cls, auth: AuthSchema, file: UploadFile, update_support: bool = False - ) -> str: + async def batch_import_user_service(cls, auth: AuthSchema, file: UploadFile, update_support: bool = False) -> str: """ 批量导入用户 @@ -590,9 +574,9 @@ class UserService: count = count + 1 # 数据转换 gender = ( - "1" if row["gender"] == "男" else ("2" if row["gender"] == "女" else "1") + "0" if row["gender"] == "男" else ("1" if row["gender"] == "女" else "2") ) - status = "0" if row["status"] == "正常" else "1" + status = 0 if row["status"] == "正常" else 1 # 构建用户数据 user_data = { @@ -607,7 +591,7 @@ class UserService: } # 处理用户导入 - exists_user = await UserCRUD(auth).get_by_username_crud( + exists_user = await UserCRUD(auth).get( username=user_data["username"] ) if exists_user: @@ -628,14 +612,14 @@ class UserService: ) new_user = await UserCRUD(auth).create(data=user_create_data) if user_create_schema.role_ids and len(user_create_schema.role_ids) > 0: - await UserCRUD(auth).set_user_roles_crud( + await UserCRUD(auth).set_user_roles( user_ids=[new_user.id], role_ids=user_create_schema.role_ids ) if ( user_create_schema.position_ids and len(user_create_schema.position_ids) > 0 ): - await UserCRUD(auth).set_user_positions_crud( + await UserCRUD(auth).set_user_positions( user_ids=[new_user.id], position_ids=user_create_schema.position_ids ) success_count += 1 @@ -651,7 +635,7 @@ class UserService: return result except Exception as e: - log.error(f"批量导入用户失败: {e!s}") + logger.error(f"批量导入用户失败: {e!s}") raise CustomException(msg=f"导入失败: {e!s}") @classmethod @@ -724,8 +708,8 @@ class UserService: item["gender"] = "男" if gender == "1" else ("女" if gender == "2" else "未知") item["is_superuser"] = "是" if item.get("is_superuser") else "否" item["creator"] = ( - item.get("creator", {}).get("name", "未知") - if isinstance(item.get("creator"), dict) + item.get("created_by", {}).get("name", "未知") + if isinstance(item.get("created_by"), dict) else "未知" ) diff --git a/backend/app/common/constant.py b/backend/app/common/constant.py index 915aeaec..6cd64be0 100644 --- a/backend/app/common/constant.py +++ b/backend/app/common/constant.py @@ -775,5 +775,6 @@ DATE_DISPLAY_FMT = "%Y-%m-%d" TIME_DISPLAY_FMT = "%H:%M:%S" DATETIME_DISPLAY_FMT = "%Y-%m-%d %H:%M:%S" + # if __name__ == "__main__": # print(RET.OK.msg) # 输出: 成功 diff --git a/backend/app/common/request.py b/backend/app/common/request.py index 2ce68cad..92089b41 100644 --- a/backend/app/common/request.py +++ b/backend/app/common/request.py @@ -1,24 +1,10 @@ from typing import Any -from pydantic import BaseModel, ConfigDict, Field -from pydantic.alias_generators import to_camel - from app.common.constant import RET +from app.core.base_schema import PageResultSchema from app.core.exceptions import CustomException -class PageResultSchema(BaseModel): - """分页查询结果模型""" - - model_config = ConfigDict(alias_generator=to_camel, from_attributes=True) - - page_no: int | None = Field(default=None, ge=1, description="页码，默认为1") - page_size: int | None = Field(default=None, ge=1, description="页面大小，默认为10") - total: int = Field(default=0, ge=0, description="总记录数") - has_next: bool | None = Field(default=False, description="是否有下一页") - items: list[Any] = Field(default_factory=list, description="分页后的数据列表") - - class PaginationService: """分页服务类（仅用于无法 SQL OFFSET/LIMIT 的数据源，如 Redis、本地文件列表、ORM 反射全量表名等）。""" @@ -27,7 +13,7 @@ class PaginationService: data_list: list[Any], page_no: int | None = None, page_size: int | None = None, - ) -> dict[str, Any]: + ) -> PageResultSchema[Any]: """ 对已在内存中的列表做切片分页。 关系型表列表请使用 CRUDBase.page（数据库分页）。 @@ -38,7 +24,7 @@ class PaginationService: - page_size (int | None): 每页数据量，默认 None。 返回: - - dict[str, Any]: 分页数据对象。 + - PageResultSchema[Any]: 分页结果对象。 异常: - CustomException: 当分页参数不合法时抛出。 @@ -65,10 +51,10 @@ class PaginationService: # 判断是否有下一页 has_next = end < total - return { - "items": paginated_data, - "total": total, - "page_no": page_no, - "page_size": page_size, - "has_next": has_next, - } + return PageResultSchema( + items=paginated_data, + total=total, + page_no=page_no, + page_size=page_size, + has_next=has_next, + ) diff --git a/backend/app/common/response.py b/backend/app/common/response.py index d1f8c302..b38418fe 100644 --- a/backend/app/common/response.py +++ b/backend/app/common/response.py @@ -65,6 +65,7 @@ class SuccessResponse(JSONResponse): success=success, ).model_dump() super().__init__(content=jsonable_response_content(content), status_code=status_code) + self.headers["Content-Type"] = "application/json; charset=utf-8" class ErrorResponse(JSONResponse): @@ -99,6 +100,7 @@ class ErrorResponse(JSONResponse): success=success, ).model_dump() super().__init__(content=jsonable_response_content(content), status_code=status_code) + self.headers["Content-Type"] = "application/json; charset=utf-8" class StreamResponse(StreamingResponse): diff --git a/backend/app/config/setting.py b/backend/app/config/setting.py index 1316a187..3238741b 100755 --- a/backend/app/config/setting.py +++ b/backend/app/config/setting.py @@ -55,7 +55,7 @@ class Settings(BaseSettings): # ******************** 跨域配置 ******************** # # ================================================= # CORS_ORIGIN_ENABLE: bool = True # 是否启用跨域 - ALLOW_ORIGINS: list[str] = ["*"] # 允许的域名列表 + ALLOW_ORIGINS: list[str] = ["http://localhost:5173", "http://localhost:4173", "http://127.0.0.1:5173", "http://localhost:5180", "http://127.0.0.1:5180"] # 允许的域名列表 ALLOW_METHODS: list[str] = ["*"] # 允许的HTTP方法 ALLOW_HEADERS: list[str] = ["*"] # 允许的请求头 ALLOW_CREDENTIALS: bool = True # 是否允许携带cookie @@ -66,8 +66,8 @@ class Settings(BaseSettings): # ================================================= # SECRET_KEY: str = "vgb0tnl9d58+6n-6h-ea&u^1#s0ccp!794=krylxcjq75vzps$" # JWT密钥 ALGORITHM: str = "HS256" # JWT算法 - ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 30 # access_token过期时间(秒)30 分钟 - REFRESH_TOKEN_EXPIRE_MINUTES: int = 60 * 30 # refresh_token过期时间(秒)30 分钟 + ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 60 * 12 # access_token过期时间(秒)12 小时 + REFRESH_TOKEN_EXPIRE_MINUTES: int = 60 * 60 * 12 # refresh_token过期时间(秒)12 小时 TOKEN_TYPE: str = "bearer" # token类型 TOKEN_REQUEST_PATH_EXCLUDE: list[str] = ["api/v1/auth/login"] # JWT / RBAC 路由白名单 TOKEN_SLIDING_EXPIRE: bool = True # 是否启用滑动过期(用户操作时自动续期) @@ -79,6 +79,22 @@ class Settings(BaseSettings): "/api/v1/common/health", ] + # ================================================= # + # ******************* 支付配置 ******************* # + # ================================================= # + PAYMENT_GATEWAY: str = "mock" # alipay / wxpay / mock + # 支付宝 + PAYMENT_ALIPAY_APP_ID: str = "" + PAYMENT_ALIPAY_PRIVATE_KEY: str = "" + PAYMENT_ALIPAY_PUBLIC_KEY: str = "" + PAYMENT_ALIPAY_SANDBOX: bool = True + # 微信支付 + PAYMENT_WXPAY_APP_ID: str = "" + PAYMENT_WXPAY_MCH_ID: str = "" + PAYMENT_WXPAY_API_KEY: str = "" + # 站点 URL（用于生成支付通知 URL） + SITE_URL: str = "http://localhost:8001" + # 多租户：通配子域与登录租户一致（默认关闭；生产按 base 解析 {code}.base） TENANT_HOST_ENFORCE: bool = False TENANT_HOST_BASE_DOMAIN: str = "" @@ -212,8 +228,6 @@ class Settings(BaseSettings): SWAGGER_CSS_URL: str = "static/swagger/swagger-ui/swagger-ui.css" SWAGGER_JS_URL: str = "static/swagger/swagger-ui/swagger-ui-bundle.js" REDOC_JS_URL: str = "static/swagger/redoc/bundles/redoc.standalone.js" - CUSTOM_CSS_URL: str = "static/swagger/custom-ui/styles.css" - CUSTOM_JS_URL: str = "static/swagger/custom-ui/scripts.js" FAVICON_URL: str = "static/image/favicon.ico" # ================================================= # @@ -251,9 +265,10 @@ class Settings(BaseSettings): MIDDLEWARES: list[str | None] = [ "app.core.middlewares.CustomCORSMiddleware" if self.CORS_ORIGIN_ENABLE else None, "app.core.middlewares.RequestLogMiddleware" if self.OPERATION_LOG_RECORD else None, - "app.core.middleware.security_headers.SecurityHeadersMiddleware", # 安全响应头 "app.core.middlewares.CustomGZipMiddleware" if self.GZIP_ENABLE else None, - "app.core.middleware.correlation.CorrelationIdMiddleware", # 请求上下文（最内层） + "app.core.middlewares.SecurityHeadersMiddleware", # 安全响应头 + "app.core.middlewares.CorrelationIdMiddleware", # 请求上下文 + "app.core.middlewares.TenantMiddleware", # 租户上下文（需 JWT） ] return MIDDLEWARES diff --git a/backend/app/core/ap_scheduler.py b/backend/app/core/ap_scheduler.py index fd7b9c66..5d0762cc 100644 --- a/backend/app/core/ap_scheduler.py +++ b/backend/app/core/ap_scheduler.py @@ -43,7 +43,7 @@ from redis.asyncio import Redis from app.config.setting import settings from app.core.database import engine -from app.core.logger import log +from app.core.logger import logger from app.plugin.module_task.cronjob.node.model import NodeModel from app.utils.cron_util import CronUtil @@ -130,7 +130,7 @@ class SchedulerUtil: cls._handle_other_event(event) except Exception as e: - log.error(f"处理任务执行事件失败: {e!s}", exc_info=True) + logger.error(f"处理任务执行事件失败: {e!s}", exc_info=True) @classmethod def _handle_job_submitted(cls, event: JobSubmissionEvent) -> None: @@ -141,7 +141,7 @@ class SchedulerUtil: job = cls.get_job(job_id=job_id) if job: - log.info(f"任务 {job_id} ({job.name}) 已提交执行") + logger.info(f"任务 {job_id} ({job.name}) 已提交执行") trigger_type = cls._get_trigger_type(job_id) @@ -169,7 +169,7 @@ class SchedulerUtil: else: original_job_id, job_name = job_id, cached_value - log.info(f"任务 {job_id} 提交执行，但未找到任务信息（可能已被移除），尝试创建日志") + logger.info(f"任务 {job_id} 提交执行，但未找到任务信息（可能已被移除），尝试创建日志") result = cls._create_job_log( job_id=original_job_id, job_name=job_name, @@ -177,9 +177,9 @@ class SchedulerUtil: status="running", ) if result: - log.info(f"任务 {original_job_id} 日志创建成功，id={result}") + logger.info(f"任务 {original_job_id} 日志创建成功，id={result}") else: - log.error(f"任务 {original_job_id} 日志创建失败") + logger.error(f"任务 {original_job_id} 日志创建失败") @classmethod def _handle_job_executed(cls, event: JobExecutionEvent) -> None: @@ -190,11 +190,11 @@ class SchedulerUtil: retval = getattr(event, "retval", None) scheduled_run_time = getattr(event, "scheduled_run_time", None) - log.info(f"任务 {job_id} 执行成功") + logger.info(f"任务 {job_id} 执行成功") if retval: - log.debug(f"任务 {job_id} 返回值: {retval}") + logger.debug(f"任务 {job_id} 返回值: {retval}") if scheduled_run_time: - log.debug(f"任务 {job_id} 计划执行时间: {scheduled_run_time}") + logger.debug(f"任务 {job_id} 计划执行时间: {scheduled_run_time}") # 更新执行日志 cls._update_latest_job_log( @@ -214,7 +214,7 @@ class SchedulerUtil: trigger_type=trigger_type, status="pending", ) - log.debug(f"任务 {job_id} 已创建新的 pending 状态日志，等待下次执行") + logger.debug(f"任务 {job_id} 已创建新的 pending 状态日志，等待下次执行") @classmethod def _handle_job_error(cls, event: JobExecutionEvent) -> None: @@ -226,11 +226,11 @@ class SchedulerUtil: traceback = getattr(event, "traceback", None) scheduled_run_time = getattr(event, "scheduled_run_time", None) - log.error(f"任务 {job_id} 执行失败: {exception!s}") + logger.error(f"任务 {job_id} 执行失败: {exception!s}") if traceback: - log.debug(f"任务 {job_id} 错误堆栈: {traceback}") + logger.debug(f"任务 {job_id} 错误堆栈: {traceback}") if scheduled_run_time: - log.debug(f"任务 {job_id} 计划执行时间: {scheduled_run_time}") + logger.debug(f"任务 {job_id} 计划执行时间: {scheduled_run_time}") # 更新执行日志 cls._update_latest_job_log( @@ -251,7 +251,7 @@ class SchedulerUtil: trigger_type=trigger_type, status="pending", ) - log.debug(f"任务 {job_id} 已创建新的 pending 状态日志，等待下次执行") + logger.debug(f"任务 {job_id} 已创建新的 pending 状态日志，等待下次执行") @classmethod def _handle_job_missed(cls, event: JobEvent) -> None: @@ -261,9 +261,9 @@ class SchedulerUtil: job_id = str(event.job_id) job = cls.get_job(job_id=job_id) - log.warning(f"任务 {job_id} 错过执行时间") + logger.warning(f"任务 {job_id} 错过执行时间") if job: - log.debug(f"任务 {job_id} ({job.name}) 错过执行") + logger.debug(f"任务 {job_id} ({job.name}) 错过执行") # 更新执行日志 cls._update_latest_job_log( @@ -283,7 +283,7 @@ class SchedulerUtil: trigger_type=trigger_type, status="pending", ) - log.debug(f"任务 {job_id} 已创建新的 pending 状态日志，等待下次执行") + logger.debug(f"任务 {job_id} 已创建新的 pending 状态日志，等待下次执行") @classmethod def _handle_job_removed(cls, event: JobEvent) -> None: @@ -298,7 +298,7 @@ class SchedulerUtil: job_id = str(event.job_id) jobstore = getattr(event, "jobstore", "unknown") - log.info(f"任务 {job_id} 从 {jobstore} 存储器中移除") + logger.info(f"任务 {job_id} 从 {jobstore} 存储器中移除") # 检查是否是一次性任务（DateTrigger） # 如果任务已经不存在，说明可能是一次性任务执行后被自动移除 @@ -307,7 +307,7 @@ class SchedulerUtil: if job is None: # 任务已经被移除，可能是一次性任务 # 不需要在这里创建日志，JOB_SUBMITTED 和 JOB_EXECUTED 会处理 - log.debug(f"任务 {job_id} 已从调度器中移除（可能是一次性任务），跳过日志更新") + logger.debug(f"任务 {job_id} 已从调度器中移除（可能是一次性任务），跳过日志更新") return # 任务还存在，说明是周期性任务被手动移除 @@ -324,20 +324,22 @@ class SchedulerUtil: job = cls.get_job(job_id=job_id) if job: - log.info(f"任务 {job_id} ({job.name}) 已添加到 {jobstore} 存储器") + logger.info(f"任务 {job_id} ({job.name}) 已添加到 {jobstore} 存储器") # 为周期性任务（cron/interval）创建初始的 pending 状态日志 trigger_type = cls._get_trigger_type(job_id) if trigger_type in ("cron", "interval"): + # 清理旧的 pending 日志，避免重启导致 pending 日志累积 + cls._cleanup_obsolete_pending_logs(job_id) cls._create_job_log( job_id=job_id, job_name=job.name, trigger_type=trigger_type, status="pending", ) - log.debug(f"任务 {job_id} 已创建初始 pending 状态日志") + logger.info(f"任务 {job_id} 已创建初始 pending 状态日志") else: - log.info(f"任务 {job_id} 已添加到 {jobstore} 存储器") + logger.info(f"任务 {job_id} 已添加到 {jobstore} 存储器") @classmethod def _handle_job_modified(cls, event: JobEvent) -> None: @@ -349,16 +351,16 @@ class SchedulerUtil: job = cls.get_job(job_id=job_id) if job: - log.info(f"任务 {job_id} ({job.name}) 已在 {jobstore} 存储器中修改") + logger.info(f"任务 {job_id} ({job.name}) 已在 {jobstore} 存储器中修改") else: - log.info(f"任务 {job_id} 已在 {jobstore} 存储器中修改") + logger.info(f"任务 {job_id} 已在 {jobstore} 存储器中修改") @classmethod def _handle_scheduler_started(cls, event: SchedulerEvent) -> None: """ 处理调度器启动事件 """ - log.info("调度器已启动") + logger.info("调度器已启动") cls._update_scheduler_status("running") @classmethod @@ -366,7 +368,7 @@ class SchedulerUtil: """ 处理调度器关闭事件 """ - log.info("调度器已关闭") + logger.info("调度器已关闭") cls._update_scheduler_status("stopped") @classmethod @@ -374,7 +376,7 @@ class SchedulerUtil: """ 处理调度器暂停事件 """ - log.info("调度器已暂停") + logger.info("调度器已暂停") cls._update_scheduler_status("paused") @classmethod @@ -382,7 +384,7 @@ class SchedulerUtil: """ 处理调度器恢复事件 """ - log.info("调度器已恢复运行") + logger.info("调度器已恢复运行") cls._update_scheduler_status("running") @classmethod @@ -392,10 +394,10 @@ class SchedulerUtil: """ alias = event.alias if alias: - log.info(f"执行器 {alias} 已添加到调度器") + logger.info(f"执行器 {alias} 已添加到调度器") cls._update_executor_info(alias, "added") else: - log.warning("执行器添加事件，但别名为空") + logger.warning("执行器添加事件，但别名为空") @classmethod def _handle_executor_removed(cls, event: SchedulerEvent) -> None: @@ -404,10 +406,10 @@ class SchedulerUtil: """ alias = event.alias if alias: - log.info(f"执行器 {alias} 已从调度器中移除") + logger.info(f"执行器 {alias} 已从调度器中移除") cls._update_executor_info(alias, "removed") else: - log.warning("执行器移除事件，但别名为空") + logger.warning("执行器移除事件，但别名为空") @classmethod def _handle_jobstore_added(cls, event: SchedulerEvent) -> None: @@ -416,10 +418,10 @@ class SchedulerUtil: """ alias = event.alias if alias: - log.info(f"JobStore {alias} 已添加到调度器") + logger.info(f"JobStore {alias} 已添加到调度器") cls._update_jobstore_info(alias, "added") else: - log.warning("JobStore 添加事件，但别名为空") + logger.warning("JobStore 添加事件，但别名为空") @classmethod def _handle_jobstore_removed(cls, event: SchedulerEvent) -> None: @@ -428,10 +430,10 @@ class SchedulerUtil: """ alias = event.alias if alias: - log.info(f"JobStore {alias} 已从调度器中移除") + logger.info(f"JobStore {alias} 已从调度器中移除") cls._update_jobstore_info(alias, "removed") else: - log.warning("JobStore 移除事件，但别名为空") + logger.warning("JobStore 移除事件，但别名为空") @classmethod def _handle_all_jobs_removed(cls, event: SchedulerEvent) -> None: @@ -439,7 +441,7 @@ class SchedulerUtil: 处理所有任务移除事件 注意：清空调度器任务不应该清空执行日志，而是将所有 pending 状态的日志更新为 cancelled """ - log.info("所有任务已从调度器中移除") + logger.info("所有任务已从调度器中移除") cls._cancel_all_pending_job_logs() @classmethod @@ -448,7 +450,7 @@ class SchedulerUtil: 处理任务达到最大实例数事件 """ job_id = str(event.job_id) - log.warning(f"任务 {job_id} 已达到最大实例数限制，无法启动新实例") + logger.warning(f"任务 {job_id} 已达到最大实例数限制，无法启动新实例") @classmethod def _handle_other_event( @@ -459,7 +461,7 @@ class SchedulerUtil: """ event_code = event.code event_type = type(event).__name__ - log.debug(f"收到未处理的事件: {event_type} (code: {event_code})") + logger.debug(f"收到未处理的事件: {event_type} (code: {event_code})") @classmethod def _update_scheduler_status(cls, status: str) -> None: @@ -492,9 +494,9 @@ class SchedulerUtil: ) session.add(param) session.commit() - log.debug(f"调度器状态已更新: {status}") + logger.info(f"调度器状态已更新: {status}") except Exception as e: - log.error(f"更新调度器状态失败: {e!s}", exc_info=True) + logger.error(f"更新调度器状态失败: {e!s}", exc_info=True) @classmethod def _update_executor_info(cls, alias: str | None, action: str) -> None: @@ -506,7 +508,7 @@ class SchedulerUtil: - action (str): 操作 (added/removed) """ if not alias: - log.warning("执行器别名为空，跳过更新") + logger.warning("执行器别名为空，跳过更新") return try: @@ -528,14 +530,14 @@ class SchedulerUtil: config_type=True, ) session.add(param) - log.debug(f"执行器 {alias} 已标记为活跃") + logger.debug(f"执行器 {alias} 已标记为活跃") elif action == "removed": if param: param.config_value = "inactive" - log.debug(f"执行器 {alias} 已标记为非活跃") + logger.debug(f"执行器 {alias} 已标记为非活跃") session.commit() except Exception as e: - log.error(f"更新执行器信息失败: {e!s}", exc_info=True) + logger.error(f"更新执行器信息失败: {e!s}", exc_info=True) @classmethod def _update_jobstore_info(cls, alias: str | None, action: str) -> None: @@ -547,7 +549,7 @@ class SchedulerUtil: - action (str): 操作 (added/removed) """ if not alias: - log.warning("JobStore 别名为空，跳过更新") + logger.warning("JobStore 别名为空，跳过更新") return try: @@ -569,14 +571,14 @@ class SchedulerUtil: config_type=True, ) session.add(param) - log.debug(f"JobStore {alias} 已标记为活跃") + logger.debug(f"JobStore {alias} 已标记为活跃") elif action == "removed": if param: param.config_value = "inactive" - log.debug(f"JobStore {alias} 已标记为非活跃") + logger.debug(f"JobStore {alias} 已标记为非活跃") session.commit() except Exception as e: - log.error(f"更新 JobStore 信息失败: {e!s}", exc_info=True) + logger.error(f"更新 JobStore 信息失败: {e!s}", exc_info=True) @classmethod def _clear_all_job_logs(cls) -> None: @@ -591,9 +593,9 @@ class SchedulerUtil: with Session(engine) as session: session.query(JobModel).delete() session.commit() - log.info("所有任务日志已清空") + logger.info("所有任务日志已清空") except Exception as e: - log.error(f"清空任务日志失败: {e!s}", exc_info=True) + logger.error(f"清空任务日志失败: {e!s}", exc_info=True) @classmethod def _cancel_all_pending_job_logs(cls) -> None: @@ -611,9 +613,9 @@ class SchedulerUtil: "status": "cancelled" }) session.commit() - log.info("所有待执行任务日志已标记为已取消") + logger.info("所有待执行任务日志已标记为已取消") except Exception as e: - log.error(f"取消待执行任务日志失败: {e!s}", exc_info=True) + logger.error(f"取消待执行任务日志失败: {e!s}", exc_info=True) @classmethod def _get_trigger_type(cls, job_id: str) -> str: @@ -653,6 +655,63 @@ class SchedulerUtil: scheduler.start() scheduler.add_listener(cls.scheduler_event_listener, EVENT_ALL) scheduler.resume() + cls._register_system_jobs() + + @classmethod + def _register_system_jobs(cls) -> None: + """ + 注册系统级定时任务（租户到期/续费提醒/归档清理/订单取消/日志清理）。 + 在 init_scheduler 末尾自动调用。 + """ + from apscheduler.triggers.cron import CronTrigger + from apscheduler.triggers.interval import IntervalTrigger + + from app.api.v1.module_platform.order.service import OrderService + from app.api.v1.module_platform.tenant.service import TenantService + + # 租户到期检查（每小时） + scheduler.add_job( + TenantService.check_tenant_expiry, + trigger=IntervalTrigger(hours=1), + id="system_tenant_expiry_check", + name="租户到期检查", + replace_existing=True, + ) + # 宽限期续费提醒（每天 9:00） + scheduler.add_job( + TenantService.send_grace_reminders, + trigger=CronTrigger(hour=9, minute=0), + id="system_grace_reminder", + name="宽限期续费提醒", + replace_existing=True, + ) + # 过期租户归档清理（每月 1 号 2:00） + scheduler.add_job( + TenantService.clean_expired_tenants, + trigger=CronTrigger(day=1, hour=2, minute=0), + id="system_clean_expired", + name="过期租户归档清理", + replace_existing=True, + ) + # 超时订单取消（每 5 分钟） + scheduler.add_job( + OrderService.cancel_expired_orders, + trigger=IntervalTrigger(minutes=5), + id="system_cancel_expired_orders", + name="超时订单取消", + replace_existing=True, + ) + # 操作日志清理（每周日 3:00） + from app.api.v1.module_system.log.service import OperationLogService + + scheduler.add_job( + OperationLogService.cleanup_operation_log, + trigger=CronTrigger(day_of_week="sun", hour=3, minute=0), + id="system_cleanup_operation_log", + name="操作日志清理", + replace_existing=True, + ) + logger.info("✅ 6 个系统周期任务已注册（租户到期/续费提醒/归档清理/订单取消/日志清理）") @classmethod def _task_wrapper(cls, job_id: str | int, code_block: str | None, *args, **kwargs): @@ -690,7 +749,7 @@ class SchedulerUtil: result = run_sync_handler() return result except Exception as e: - log.error(f"任务 {job_id} 执行失败: {e!s}") + logger.error(f"任务 {job_id} 执行失败: {e!s}") raise @classmethod @@ -801,6 +860,26 @@ class SchedulerUtil: except Exception as e: return {"error": str(e), "raw_data": str(blob_data[:200])} + @classmethod + def _cleanup_obsolete_pending_logs(cls, job_id: str) -> None: + """清理该 job_id 的所有旧的 pending 日志，避免重启累积。""" + from sqlalchemy.orm import Session + + from app.plugin.module_task.cronjob.job.model import JobModel + + try: + with Session(engine) as session: + deleted = ( + session.query(JobModel) + .filter(JobModel.job_id == job_id, JobModel.status == "pending") + .delete(synchronize_session=False) + ) + session.commit() + if deleted: + logger.info(f"清理了任务 {job_id} 的 {deleted} 条旧 pending 日志") + except Exception as e: + logger.error(f"清理任务 {job_id} 旧 pending 日志失败: {e}") + @classmethod def _create_job_log( cls, @@ -835,10 +914,10 @@ class SchedulerUtil: ) session.add(job_log) session.commit() - log.info(f"执行日志创建成功: job_id={job_id}, id={job_log.id}") + logger.info(f"执行日志创建成功: job_id={job_id}, id={job_log.id}") return job_log.id except Exception as e: - log.error(f"创建执行日志失败: job_id={job_id}, error={e}", exc_info=True) + logger.error(f"创建执行日志失败: job_id={job_id}, error={e}", exc_info=True) return None @classmethod @@ -877,7 +956,7 @@ class SchedulerUtil: job_log.error = error session.commit() else: - log.warning(f"未找到任务 {job_id} 的待执行日志记录") + logger.warning(f"未找到任务 {job_id} 的待执行日志记录") @classmethod def _update_latest_job_log( @@ -916,7 +995,7 @@ class SchedulerUtil: if error: job_log.error = error session.commit() - log.info(f"执行日志更新成功: job_id={job_id}, id={job_log.id}, status={status}") + logger.info(f"执行日志更新成功: job_id={job_id}, id={job_log.id}, status={status}") return # 没有找到 running 状态的日志，尝试更新 cancelled 状态的日志 @@ -939,11 +1018,11 @@ class SchedulerUtil: if error: job_log.error = error session.commit() - log.info(f"执行日志更新成功: job_id={job_id}, id={job_log.id}, status={status}") + logger.info(f"执行日志更新成功: job_id={job_id}, id={job_log.id}, status={status}") return # 创建新的日志记录 - log.debug(f"未找到任务 {job_id} 的日志记录，创建新日志") + logger.debug(f"未找到任务 {job_id} 的日志记录，创建新日志") trigger_type = cls._get_trigger_type(job_id) if job else "manual" new_log = JobModel( job_id=job_id, @@ -957,9 +1036,9 @@ class SchedulerUtil: ) session.add(new_log) session.commit() - log.info(f"执行日志创建成功: job_id={job_id}, id={new_log.id}, status={status}") + logger.info(f"执行日志创建成功: job_id={job_id}, id={new_log.id}, status={status}") except Exception as e: - log.error( + logger.error( f"更新执行日志失败: job_id={job_id}, status={status}, error={e}", exc_info=True ) @@ -1004,7 +1083,7 @@ class SchedulerUtil: if job_log: job_log.status = "cancelled" session.commit() - log.info(f"任务 {job_id} 的执行日志已标记为已取消") + logger.info(f"任务 {job_id} 的执行日志已标记为已取消") @classmethod def get_job_status(cls, job_id: str | int) -> str: @@ -1216,7 +1295,7 @@ class SchedulerUtil: jobstore=jobstore, executor=executor, ) - log.info(f"任务 {job_info.id} 添加到 {jobstore} 存储器成功") + logger.info(f"任务 {job_info.id} 添加到 {jobstore} 存储器成功") return job except ConflictingIdError: scheduler.remove_job(job_id=str(job_info.id), jobstore=jobstore) @@ -1232,7 +1311,7 @@ class SchedulerUtil: jobstore=jobstore, executor=executor, ) - log.info(f"任务 {job_info.id} 已存在，已移除旧任务并重新添加") + logger.info(f"任务 {job_info.id} 已存在，已移除旧任务并重新添加") return job @classmethod @@ -1527,5 +1606,5 @@ class SchedulerUtil: max_instances=1, ) - log.info(f"任务 {job_id} 已触发立即执行，临时任务 ID: {temp_job_id}") + logger.info(f"任务 {job_id} 已触发立即执行，临时任务 ID: {temp_job_id}") return temp_job diff --git a/backend/app/core/auth_schema.py b/backend/app/core/auth_schema.py deleted file mode 100644 index 762d8a66..00000000 --- a/backend/app/core/auth_schema.py +++ /dev/null @@ -1,70 +0,0 @@ -"""认证授权相关的基础 Schema - -放置在此处避免循环导入问题 -""" -from datetime import datetime -from typing import TYPE_CHECKING - -from pydantic import BaseModel, ConfigDict, Field, model_validator -from sqlalchemy.ext.asyncio import AsyncSession - -# 使用 TYPE_CHECKING 避免循环导入 -if TYPE_CHECKING: - from app.api.v1.module_system.user.model import UserModel - - -class AuthSchema(BaseModel): - """权限认证模型""" - - model_config = ConfigDict(arbitrary_types_allowed=True) - - user: "UserModel | None" = Field(default=None, description="用户信息") - check_data_scope: bool = Field(default=True, description="是否检查数据权限") - db: AsyncSession = Field(description="数据库会话") - tenant_id: int | None = Field(default=None, description="租户ID,用于用户认证前查询") - - -class JWTPayloadSchema(BaseModel): - """JWT载荷模型""" - - sub: str = Field(..., description="用户登录信息") - is_refresh: bool = Field(default=False, description="是否刷新token") - exp: datetime | int = Field(..., description="过期时间") - - @model_validator(mode="after") - def validate_fields(self): - """ - 校验 JWT 载荷字段的基本合法性。 - - 返回: - - JWTPayloadSchema: 校验后的载荷实例。 - - 异常: - - ValueError: 必填字段为空或格式不正确时抛出。 - """ - if not self.sub or len(self.sub.strip()) == 0: - raise ValueError("会话编号不能为空") - return self - - -class JWTOutSchema(BaseModel): - """JWT响应模型""" - - model_config = ConfigDict(from_attributes=True) - - access_token: str = Field(..., min_length=1, description="访问token") - refresh_token: str = Field(..., min_length=1, description="刷新token") - token_type: str = Field(default="Bearer", description="token类型") - expires_in: int = Field(..., gt=0, description="过期时间(秒)") - - -class RefreshTokenPayloadSchema(BaseModel): - """刷新Token载荷模型""" - - refresh_token: str = Field(..., min_length=1, description="刷新token") - - -class LogoutPayloadSchema(BaseModel): - """退出登录载荷模型""" - - token: str = Field(..., min_length=1, description="token") \ No newline at end of file diff --git a/backend/app/core/base_crud.py b/backend/app/core/base_crud.py index 44a7eb97..d4b4a970 100644 --- a/backend/app/core/base_crud.py +++ b/backend/app/core/base_crud.py @@ -1,16 +1,35 @@ +""""统一 CRUD 基类 — 同时支持有认证和无认证场景 + +- 当 `auth` 不为 None 时（Controller 注入）：自动处理租户隔离、数据权限过滤、审计字段填充 +- 当 `auth` 为 None 时（后台任务/脚本）：纯数据操作，无权限/租户过滤 + +用法: + # 带认证（Controller） + class UserCRUD(CRUDBase[UserModel, UserCreateSchema, UserUpdateSchema]): + def __init__(self, auth: AuthSchema) -> None: + super().__init__(model=UserModel, auth=auth) + + # 无认证（后台任务） + class OrderCRUD(CRUDBase[OrderModel, Any, Any]): + def __init__(self, session: AsyncSession) -> None: + super().__init__(model=OrderModel, session=session) +""" + import builtins from collections.abc import Sequence -from datetime import datetime +from datetime import datetime, timedelta from typing import TYPE_CHECKING, Any, Generic, TypeVar from pydantic import BaseModel -from sqlalchemy import Select, asc, delete, desc, false, func, select, update +from sqlalchemy import Select, asc, delete, desc, false, func, literal_column, select, update from sqlalchemy import inspect as sa_inspect +from sqlalchemy.ext.asyncio import AsyncSession from sqlalchemy.orm import selectinload from sqlalchemy.sql.elements import ColumnElement -from app.api.v1.module_system.auth.schema import AuthSchema from app.core.base_model import MappedBase +from app.core.base_schema import AuthSchema, PageResultSchema +from app.core.database import async_db_session from app.core.exceptions import CustomException from app.core.permission import Permission @@ -24,50 +43,132 @@ OutSchemaType = TypeVar("OutSchemaType", bound=BaseModel) class CRUDBase(Generic[ModelType, CreateSchemaType, UpdateSchemaType]): - """基础数据层""" + """统一数据层基类 — 有认证时自动处理权限，无认证时纯数据操作""" - def __init__(self, model: type[ModelType], auth: AuthSchema) -> None: + def __init__( + self, + model: type[ModelType], + auth: AuthSchema | None = None, + session: AsyncSession | None = None, + ) -> None: """ - 初始化CRUDBase类 + 初始化 CRUDBase。 参数: - - model (Type[ModelType]): 数据模型类。 - - auth (AuthSchema): 认证信息。 - - 返回: - - None + - model: 数据模型类 + - auth: 认证信息（Controller 场景），为 None 时跳过所有权限/租户/审计逻辑 + - session: 数据库会话（后台任务场景），仅在 auth=None 时使用 """ self.model = model self.auth = auth + self.db = session if session is not None else (auth.db if auth else None) + if self.db is None: + raise RuntimeError( + "CRUDBase 未初始化数据库会话，请传入 auth 或 session 参数" + ) - async def get(self, preload: list[str | Any] | None = None, **kwargs) -> ModelType | None: - """ - 根据条件获取单个对象 + def _get_pk_col(self) -> ColumnElement: + """获取模型主键列""" + mapper = sa_inspect(self.model) + pk_cols = list(getattr(mapper, "primary_key", [])) + if not pk_cols: + raise CustomException(msg="模型缺少主键") + if len(pk_cols) > 1: + raise CustomException(msg="暂不支持复合主键操作") + return pk_cols[0] + + @property + def _supports_soft_delete(self) -> bool: + """模型是否支持软删除""" + return all( + hasattr(self.model, attr) for attr in ("is_deleted", "deleted_time", "deleted_id") + ) + + def _soft_delete_values(self) -> dict[str, Any]: + """软删除时需要更新的字段值""" + data: dict[str, Any] = {"is_deleted": True, "deleted_time": datetime.now()} + if self.auth and self.auth.user: + data["deleted_id"] = self.auth.user.id + return data + + # ── 查询 ── + async def _get_one( + self, session: AsyncSession, preload: list[str | Any] | None = None, **kwargs + ) -> ModelType | None: + """内部方法：在指定会话上执行单条查询（get / update 共用） 参数: - - preload (Optional[List[Union[str, Any]]]): 预加载关系，支持关系名字符串或SQLAlchemy loader option + - session: 数据库会话（只读 or 事务） + - preload: 预加载关系 - **kwargs: 查询条件 返回: - - Optional[ModelType]: 对象实例 + - 对象实例或 None + """ + conditions = await self.__build_conditions(**kwargs) + sql = select(self.model).where(*conditions) + for opt in self.__loader_options(preload): + sql = sql.options(opt) + sql = await self.__filter_permissions(sql) + result: Result = await session.execute(sql) + return result.scalars().first() - 异常: - - CustomException: 查询失败时抛出异常 + async def get(self, preload: list[str | Any] | None = None, **kwargs) -> ModelType | None: + """ + 根据条件获取单个对象（使用只读会话，不参与请求事务） + + 参数: + - preload: 预加载关系 + - **kwargs: 查询条件 + + 返回: + - 对象实例或 None + """ + try: + async with async_db_session() as rdb: + return await self._get_one(rdb, preload=preload, **kwargs) + except CustomException: + raise + except Exception as e: + raise CustomException(msg=f"获取查询失败: {e!s}") + + async def get_by_id(self, model_id: int) -> ModelType | None: + """按主键查询""" + return await self.get(id=model_id) + + async def exists(self, **kwargs) -> bool: + """ + 检查是否存在符合条件的记录 + + 参数: + - **kwargs: 查询条件 + + 返回: + - 是否存在 + """ + return await self.get(**kwargs) is not None + + async def count(self, **kwargs) -> int: + """ + 统计符合条件的记录数（使用只读会话，不参与请求事务） + + 参数: + - **kwargs: 查询条件，支持元组语法 + + 返回: + - 记录数 """ try: conditions = await self.__build_conditions(**kwargs) - sql = select(self.model).where(*conditions) - # 应用可配置的预加载选项 - for opt in self.__loader_options(preload): - sql = sql.options(opt) - - sql = await self.__filter_permissions(sql) - - result: Result = await self.auth.db.execute(sql) - obj = result.scalars().first() - return obj + count_sql = select(func.count()).select_from(self.model).where(*conditions) + count_sql = await self.__filter_permissions(count_sql) + async with async_db_session() as rdb: + result = await rdb.execute(count_sql) + return result.scalar() or 0 + except CustomException: + raise except Exception as e: - raise CustomException(msg=f"获取查询失败: {e!s}") + raise CustomException(msg=f"统计失败: {e!s}") async def list( self, @@ -76,29 +177,28 @@ class CRUDBase(Generic[ModelType, CreateSchemaType, UpdateSchemaType]): preload: list[str | Any] | None = None, ) -> Sequence[ModelType]: """ - 根据条件获取对象列表 + 根据条件获取对象列表（使用只读会话，不参与请求事务） 参数: - - search (Optional[Dict]): 查询条件,格式为 {'id': value, 'name': value} - - order_by (Optional[List[Dict[str, str]]]): 排序字段,格式为 [{'id': 'asc'}, {'name': 'desc'}] - - preload (Optional[List[Union[str, Any]]]): 预加载关系，支持关系名字符串或SQLAlchemy loader option + - search: 查询条件 + - order_by: 排序字段, 格式为 [{'id': 'asc'}, {'name': 'desc'}] + - preload: 预加载关系 返回: - - Sequence[ModelType]: 对象列表 - - 异常: - - CustomException: 查询失败时抛出异常 + - 对象列表 """ try: - conditions = await self.__build_conditions(**search) if search else [] + conditions = await self.__build_conditions(**(search or {})) order = order_by or [{"id": "asc"}] - sql = select(self.model).where(*conditions).order_by(*self.__order_by(order)) - # 应用可配置的预加载选项 + sql = select(self.model).where(*conditions).order_by(*self._parse_order(order)) for opt in self.__loader_options(preload): sql = sql.options(opt) sql = await self.__filter_permissions(sql) - result: Result = await self.auth.db.execute(sql) + async with async_db_session() as rdb: + result: Result = await rdb.execute(sql) return result.scalars().all() + except CustomException: + raise except Exception as e: raise CustomException(msg=f"列表查询失败: {e!s}") @@ -110,41 +210,36 @@ class CRUDBase(Generic[ModelType, CreateSchemaType, UpdateSchemaType]): preload: builtins.list[str | Any] | None = None, ) -> Sequence[ModelType]: """ - 获取树形结构数据列表 + 获取树形结构数据列表（使用只读会话，不参与请求事务） 参数: - - search (Optional[Dict]): 查询条件 - - order_by (Optional[List[Dict[str, str]]]): 排序字段 - - children_attr (str): 子节点属性名 - - preload (Optional[List[Union[str, Any]]]): 额外预加载关系，若为None则默认包含children_attr + - search: 查询条件 + - order_by: 排序字段 + - children_attr: 子节点属性名 + - preload: 额外预加载关系 返回: - - Sequence[ModelType]: 树形结构数据列表 - - 异常: - - CustomException: 查询失败时抛出异常 + - 树形结构数据列表 """ try: - conditions = await self.__build_conditions(**search) if search else [] + conditions = await self.__build_conditions(**(search or {})) order = order_by or [{"id": "asc"}] - sql = select(self.model).where(*conditions).order_by(*self.__order_by(order)) + sql = select(self.model).where(*conditions).order_by(*self._parse_order(order)) - # 处理预加载选项 final_preload = preload - # 如果没有提供preload且children_attr存在，则添加到预加载选项中 if preload is None and children_attr and hasattr(self.model, children_attr): - # 获取模型默认预加载选项 model_defaults = getattr(self.model, "__loader_options__", []) - # 将children_attr添加到默认预加载选项中 final_preload = [*list(model_defaults), children_attr] - # 应用预加载选项 for opt in self.__loader_options(final_preload): sql = sql.options(opt) sql = await self.__filter_permissions(sql) - result: Result = await self.auth.db.execute(sql) + async with async_db_session() as rdb: + result: Result = await rdb.execute(sql) return result.scalars().all() + except CustomException: + raise except Exception as e: raise CustomException(msg=f"树形列表查询失败: {e!s}") @@ -154,83 +249,85 @@ class CRUDBase(Generic[ModelType, CreateSchemaType, UpdateSchemaType]): limit: int, order_by: builtins.list[dict[str, str]], search: dict, - out_schema: type[OutSchemaType], + out_schema: type[OutSchemaType] | None = None, preload: builtins.list[str | Any] | None = None, - ) -> dict: + ) -> PageResultSchema: """ - 获取分页数据 + 获取分页数据（使用只读会话，不参与请求事务；count 与 data 共享同一会话） 参数: - - offset (int): 偏移量 - - limit (int): 每页数量 - - order_by (List[Dict[str, str]]): 排序字段 - - search (Dict): 查询条件 - - out_schema (Type[OutSchemaType]): 输出数据模型 - - preload (Optional[List[Union[str, Any]]]): 预加载关系 + - offset: 偏移量 + - limit: 每页数量 + - order_by: 排序字段 + - search: 查询条件 + - out_schema: 输出数据模型（None 时返回原始 ORM 对象） + - preload: 预加载关系 返回: - - Dict: 分页数据 - - 异常: - - CustomException: 查询失败时抛出异常 + - PageResultSchema: 分页结果 """ try: - conditions = await self.__build_conditions(**search) if search else [] + conditions = await self.__build_conditions(**(search or {})) order = order_by or [{"id": "asc"}] - sql = select(self.model).where(*conditions).order_by(*self.__order_by(order)) - # 应用预加载选项 - for opt in self.__loader_options(preload): - sql = sql.options(opt) - sql = await self.__filter_permissions(sql) - # 优化count查询：使用主键计数而非全表扫描 mapper = sa_inspect(self.model) pk_cols = list(getattr(mapper, "primary_key", [])) - if pk_cols: - # 使用主键的第一列进行计数（主键必定非NULL，性能更好） - count_sql = select(func.count(pk_cols[0])).select_from(self.model) - else: - # 降级方案：使用count(*) - count_sql = select(func.count()).select_from(self.model) + pk = pk_cols[0] if pk_cols else literal_column("1") - if conditions: - count_sql = count_sql.where(*conditions) - count_sql = await self.__filter_permissions(count_sql) + data_sql = select(self.model).where(*conditions) + for opt in self.__loader_options(preload): + data_sql = data_sql.options(opt) + data_sql = await self.__filter_permissions(data_sql) - total_result = await self.auth.db.execute(count_sql) - total = total_result.scalar() or 0 + count_sql = select(func.count(pk)).select_from(self.model) + where_clause = data_sql.whereclause + if where_clause is not None: + count_sql = count_sql.where(where_clause) - result: Result = await self.auth.db.execute(sql.offset(offset).limit(limit)) - objs = result.scalars().all() + async with async_db_session() as rdb: + total_result = await rdb.execute(count_sql) + total = total_result.scalar() or 0 - return { - "page_no": offset // limit + 1 if limit else 1, - "page_size": limit or 10, - "total": total, - "has_next": offset + limit < total, - "items": [out_schema.model_validate(obj).model_dump() for obj in objs], - } + result: Result = await rdb.execute( + data_sql.order_by(*self._parse_order(order)).offset(offset).limit(limit) + ) + objs = result.scalars().all() + + items = ( + [out_schema.model_validate(obj).model_dump() for obj in objs] + if out_schema + else list(objs) + ) + + return PageResultSchema( + page_no=offset // limit + 1 if limit else 1, + page_size=limit or 10, + total=total, + has_next=offset + limit < total, + items=items, + ) + except CustomException: + raise except Exception as e: raise CustomException(msg=f"分页查询失败: {e!s}") - async def create(self, data: CreateSchemaType | dict) -> ModelType: - """ - 创建新对象 + # ── 创建 ── + async def create(self, data: CreateSchemaType) -> ModelType: + """创建新对象（有认证时自动填充租户与审计字段） + + 事务由 request 级 db_getter 统一管理，本方法不开启独立事务。 参数: - - data (Union[CreateSchemaType, Dict]): 对象属性 + - data: 对象属性 返回: - - ModelType: 新创建的对象实例 - - 异常: - - CustomException: 创建失败时抛出异常 + - 新创建的对象实例 """ try: - obj_dict = data if isinstance(data, dict) else data.model_dump() + obj_dict = data.model_dump() obj = self.model(**obj_dict) - if self.auth.user: + if self.auth and self.auth.user: if hasattr(obj, "tenant_id") and getattr(obj, "tenant_id", None) is None: setattr(obj, "tenant_id", self.auth.user.tenant_id) if hasattr(obj, "created_id"): @@ -238,39 +335,36 @@ class CRUDBase(Generic[ModelType, CreateSchemaType, UpdateSchemaType]): if hasattr(obj, "updated_id"): setattr(obj, "updated_id", self.auth.user.id) - self.auth.db.add(obj) - await self.auth.db.flush() - await self.auth.db.refresh(obj) + self.db.add(obj) + await self.db.flush() + await self.db.refresh(obj) return obj + except CustomException: + raise except Exception as e: raise CustomException(msg=f"创建失败: {e!s}") - async def update(self, id: int, data: UpdateSchemaType | dict) -> ModelType: - """ - 更新对象 + # ── 更新 ── + async def update(self, id: int, data: UpdateSchemaType) -> ModelType: + """更新对象（有认证时检查租户归属 + 填充审计字段） + + 事务由 request 级 db_getter 统一管理，本方法不开启独立事务。 参数: - - id (int): 对象ID - - data (Union[UpdateSchemaType, Dict]): 更新的属性及值 + - id: 对象 ID + - data: 更新属性 返回: - - ModelType: 更新后的对象实例 - - 异常: - - CustomException: 更新失败时抛出异常 + - 更新后的对象实例 """ try: - obj_dict = ( - data - if isinstance(data, dict) - else data.model_dump(exclude_unset=True, exclude={"id"}) - ) - # 获取对象时不自动预加载关系，避免循环依赖 - obj = await self.get(id=id, preload=[]) + obj_dict = data.model_dump(exclude_unset=True, exclude={"id"}) + obj = await self._get_one(self.db, id=id, preload=[]) if not obj: raise CustomException(msg="更新对象不存在") - if self.auth.user and not self.auth.user.is_superuser: + # 租户权限检查（仅在有认证且非超管时） + if self.auth and self.auth.user and not self.auth.user.is_superuser: if hasattr(obj, "tenant_id"): obj_tid = getattr(obj, "tenant_id", None) if obj_tid is not None and obj_tid != self.auth.user.tenant_id: @@ -279,250 +373,174 @@ class CRUDBase(Generic[ModelType, CreateSchemaType, UpdateSchemaType]): raise CustomException(msg="平台数据仅管理员可修改") raise CustomException(msg="无权修改其他租户的数据") - # 设置字段值（只检查一次current_user） - if self.auth.user and hasattr(obj, "updated_id"): + # 审计字段 + if self.auth and self.auth.user and hasattr(obj, "updated_id"): setattr(obj, "updated_id", self.auth.user.id) for key, value in obj_dict.items(): if hasattr(obj, key): setattr(obj, key, value) - await self.auth.db.flush() - # 刷新对象时不自动预加载关系 - await self.auth.db.refresh(obj) - - # 权限二次确认：flush后再次验证对象仍在权限范围内 - # 防止并发修改导致的权限逃逸（如其他事务修改了created_id） - # 验证时也不自动预加载关系 - verify_obj = await self.get(id=id, preload=[]) - if not verify_obj: - # 对象已被删除或权限已失效 - raise CustomException(msg="更新失败，对象不存在或无权限访问") - + await self.db.flush() + await self.db.refresh(obj) return obj + except CustomException: + raise except Exception as e: raise CustomException(msg=f"更新失败: {e!s}") - def __tenant_condition(self, read_mode: bool = False) -> builtins.list[ColumnElement]: - """ - 获取租户隔离条件。 - - read_mode=True 时对标记了 __platform_data_shared__ 的模型会同时放开 - tenant_id=1（平台数据），使租户用户也能读取平台共享数据；写入操作不受此影响。 - - 返回: - - List[ColumnElement]: 租户过滤条件列表，超管或无 tenant_id 字段时返回空列表。 - """ - if not hasattr(self.model, "tenant_id"): - return [] - if self.auth.user and self.auth.user.is_superuser: - return [] - tid = self.auth.user.tenant_id if self.auth.user else self.auth.tenant_id - if tid is not None: - own_filter = getattr(self.model, "tenant_id") == tid - if read_mode and getattr(self.model, "__platform_data_shared__", False) and tid != 1: - platform_filter = getattr(self.model, "tenant_id") == 1 - return [own_filter | platform_filter] - return [own_filter] - return [] - + # ── 删除 ── async def delete(self, ids: builtins.list[int]) -> None: - """ - 软删除对象 + """软删除对象（有认证时加租户隔离 + 填充删除人） + + 事务由 request 级 db_getter 统一管理，本方法不开启独立事务。 参数: - - ids (List[int]): 对象ID列表 - - 返回: - - None - - 异常: - - CustomException: 删除失败时抛出异常 + - ids: 对象 ID 列表 """ try: - mapper = sa_inspect(self.model) - pk_cols = list(getattr(mapper, "primary_key", [])) - if not pk_cols: - raise CustomException(msg="模型缺少主键，无法删除") - if len(pk_cols) > 1: - raise CustomException(msg="暂不支持复合主键的批量删除") + pk = self._get_pk_col() + tenant_conds = self.__tenant_condition() - # 检查模型是否支持软删除 - if ( - hasattr(self.model, "is_deleted") - and hasattr(self.model, "deleted_time") - and hasattr(self.model, "deleted_id") - ): - # 执行软删除 - update_data = {"is_deleted": True, "deleted_time": datetime.now()} - # 如果有当前用户，设置删除人ID - if self.auth.user: - update_data["deleted_id"] = self.auth.user.id - - # 只更新有权限的数据（主键 + 租户隔离） + if self._supports_soft_delete: sql = ( update(self.model) - .where(pk_cols[0].in_(ids), *self.__tenant_condition()) - .values(**update_data) + .where(pk.in_(ids), *tenant_conds) + .values(**self._soft_delete_values()) ) - await self.auth.db.execute(sql) - await self.auth.db.flush() + await self.db.execute(sql) else: - # 不支持软删除的模型，执行物理删除（租户隔离） - sql = delete(self.model).where(pk_cols[0].in_(ids), *self.__tenant_condition()) - await self.auth.db.execute(sql) - await self.auth.db.flush() + sql = delete(self.model).where(pk.in_(ids), *tenant_conds) + await self.db.execute(sql) + await self.db.flush() + except CustomException: + raise except Exception as e: raise CustomException(msg=f"删除失败: {e!s}") async def clear(self) -> None: - """ - 软清空对象表 + """软清空对象表（有认证时租户隔离） - 返回: - - None - - 异常: - - CustomException: 清空失败时抛出异常 + 事务由 request 级 db_getter 统一管理，本方法不开启独立事务。 """ try: - # 检查模型是否支持软删除 - if ( - hasattr(self.model, "is_deleted") - and hasattr(self.model, "deleted_time") - and hasattr(self.model, "deleted_id") - ): - # 执行软删除 - update_data = {"is_deleted": True, "deleted_time": datetime.now()} - # 如果有当前用户，设置删除人ID - if self.auth.user: - update_data["deleted_id"] = self.auth.user.id + tenant_conds = self.__tenant_condition() - # 更新所有数据为软删除状态（租户隔离） - sql = update(self.model).where(*self.__tenant_condition()).values(**update_data) - await self.auth.db.execute(sql) - await self.auth.db.flush() + if self._supports_soft_delete: + sql = update(self.model).where(*tenant_conds).values(**self._soft_delete_values()) + await self.db.execute(sql) else: - # 不支持软删除的模型，执行物理删除 - sql = delete(self.model) - await self.auth.db.execute(sql) - await self.auth.db.flush() + sql = delete(self.model).where(*tenant_conds) + await self.db.execute(sql) + await self.db.flush() + except CustomException: + raise except Exception as e: raise CustomException(msg=f"清空失败: {e!s}") + # ── 批量操作 ── async def set(self, ids: builtins.list[int], **kwargs) -> None: - """ - 批量更新对象 + """批量更新字段（有认证时租户隔离） + + 事务由 request 级 db_getter 统一管理，本方法不开启独立事务。 参数: - - ids (List[int]): 对象ID列表 - - **kwargs: 更新的属性及值 - - 返回: - - None - - 异常: - - CustomException: 更新失败时抛出异常 + - ids: 对象 ID 列表 + - **kwargs: 更新属性及值 """ try: - mapper = sa_inspect(self.model) - pk_cols = list(getattr(mapper, "primary_key", [])) - if not pk_cols: - raise CustomException(msg="模型缺少主键，无法更新") - if len(pk_cols) > 1: - raise CustomException(msg="暂不支持复合主键的批量更新") - - # 只更新有权限的数据（主键 + 租户隔离） + pk = self._get_pk_col() sql = ( update(self.model) - .where(pk_cols[0].in_(ids), *self.__tenant_condition()) + .where(pk.in_(ids), *self.__tenant_condition()) .values(**kwargs) ) - await self.auth.db.execute(sql) - await self.auth.db.flush() + await self.db.execute(sql) + await self.db.flush() except CustomException: raise except Exception as e: raise CustomException(msg=f"批量更新失败: {e!s}") async def restore(self, ids: builtins.list[int]) -> None: - """ - 恢复软删除的对象 + """恢复软删除对象（有认证时租户隔离） + + 事务由 request 级 db_getter 统一管理，本方法不开启独立事务。 参数: - - ids (List[int]): 对象ID列表 - - 返回: - - None - - 异常: - - CustomException: 恢复失败时抛出异常 + - ids: 对象 ID 列表 """ try: - mapper = sa_inspect(self.model) - pk_cols = list(getattr(mapper, "primary_key", [])) - if not pk_cols: - raise CustomException(msg="模型缺少主键，无法恢复") - if len(pk_cols) > 1: - raise CustomException(msg="暂不支持复合主键的批量恢复") - - # 检查模型是否支持软删除 - if ( - hasattr(self.model, "is_deleted") - and hasattr(self.model, "deleted_time") - and hasattr(self.model, "deleted_id") - ): - # 执行恢复操作 - update_data = {"is_deleted": False, "deleted_time": None, "deleted_id": None} - - # 只更新有权限的数据（主键 + 租户隔离） - sql = ( - update(self.model) - .where(pk_cols[0].in_(ids), *self.__tenant_condition()) - .values(**update_data) - ) - await self.auth.db.execute(sql) - await self.auth.db.flush() - else: + if not self._supports_soft_delete: raise CustomException(msg="该模型不支持软删除，无法恢复") + pk = self._get_pk_col() + sql = ( + update(self.model) + .where(pk.in_(ids), *self.__tenant_condition()) + .values(is_deleted=False, deleted_time=None, deleted_id=None) + ) + await self.db.execute(sql) + await self.db.flush() except CustomException: raise except Exception as e: raise CustomException(msg=f"恢复失败: {e!s}") + # ── 内部方法 ── + def __tenant_condition(self) -> builtins.list[ColumnElement]: + """ + 获取租户隔离条件（无认证时返回空列表） + + 返回: + - 租户过滤条件列表 + """ + if not self.auth or not self.auth.user: + return [] + if self.auth.user.is_superuser: + return [] + if not hasattr(self.model, "tenant_id"): + return [] + tid = self.auth.user.tenant_id + if tid is not None: + return [getattr(self.model, "tenant_id") == tid] + return [] + async def __filter_permissions(self, sql: Select) -> Select: - """ - 过滤数据权限（仅用于Select）：先按租户隔离，再按业务权限策略过滤。 - """ - for condition in self.__tenant_condition(read_mode=True): - sql = sql.where(condition) - filter = Permission(model=self.model, auth=self.auth) - return await filter.filter_query(sql) + """过滤数据权限（仅用于 Select）""" + if not self.auth: + return sql + if getattr(self.model, "__platform_data_shared__", False): + for condition in self._platform_shared_conditions(): + sql = sql.where(condition) + filter_obj = Permission(model=self.model, auth=self.auth) + return await filter_obj.filter_query(sql) + + def _platform_shared_conditions(self) -> builtins.list[ColumnElement]: + """平台共享模型读取条件（租户可读 tenant_id=平台或自己的数据）""" + if not self.auth or not self.auth.user: + return [] + tid = self.auth.user.tenant_id + if tid is not None and tid != 1: + return [ + (getattr(self.model, "tenant_id") == tid) + | (getattr(self.model, "tenant_id") == 1) + ] + return [] async def __build_conditions(self, **kwargs) -> builtins.list[ColumnElement]: """ - 构建查询条件 + 构建查询条件（自动添加 is_deleted 过滤） 参数: - - **kwargs: 查询参数 + - **kwargs: 查询参数，支持元组语法: ("like", val), ("in", []), ("between", [a,b]) 等 返回: - - List[ColumnElement]: SQL条件表达式列表 - - 异常: - - CustomException: 查询参数不存在时抛出异常 + - SQL 条件表达式列表 """ - conditions = [] - # 默认添加软删除条件，只查询未删除的数据 - if hasattr(self.model, "is_deleted"): - conditions.append(getattr(self.model, "is_deleted") == False) + conditions: builtins.list[ColumnElement] = [] - # 多租户数据隔离：非超管自动按 tenant_id 过滤 - if hasattr(self.model, "tenant_id"): - if not self.auth.user or not self.auth.user.is_superuser: - tid = self.auth.user.tenant_id if self.auth.user else self.auth.tenant_id - if tid is not None: - conditions.append(getattr(self.model, "tenant_id") == tid) + if hasattr(self.model, "is_deleted"): + conditions.append(getattr(self.model, "is_deleted") == False) # noqa: E712 for key, value in kwargs.items(): if value is None or value == "": @@ -536,13 +554,21 @@ class CRUDBase(Generic[ModelType, CreateSchemaType, UpdateSchemaType]): elif seq == "not None": conditions.append(attr.isnot(None)) elif seq == "date" and val: - conditions.append(func.date_format(attr, "%Y-%m-%d") == val) + dt = datetime.strptime(val, "%Y-%m-%d") + conditions.append(attr >= dt) + conditions.append(attr < dt + timedelta(days=1)) elif seq == "month" and val: - conditions.append(func.date_format(attr, "%Y-%m") == val) + dt = datetime.strptime(val, "%Y-%m") + next_month = ( + dt.replace(year=dt.year + 1, month=1) + if dt.month == 12 + else dt.replace(month=dt.month + 1) + ) + conditions.append(attr >= dt) + conditions.append(attr < next_month) elif seq == "like" and val: conditions.append(attr.like(f"%{val}%")) elif seq == "in": - # 通用约定：("in", []) 应当返回空集（恒假），不能跳过条件导致查询退化成全量（仅权限过滤） if val is None: continue if isinstance(val, (list, tuple, set)) and len(val) == 0: @@ -551,38 +577,37 @@ class CRUDBase(Generic[ModelType, CreateSchemaType, UpdateSchemaType]): conditions.append(attr.in_(val)) elif seq == "between" and isinstance(val, (list, tuple)) and len(val) == 2: conditions.append(attr.between(val[0], val[1])) - elif seq == "!=" or (seq == "ne" and val): + elif seq in ("!=", "ne") and val is not None: conditions.append(attr != val) - elif seq == ">" or (seq == "gt" and val): + elif seq in (">", "gt") and val is not None: conditions.append(attr > val) - elif seq == ">=" or (seq == "ge" and val): + elif seq in (">=", "ge") and val is not None: conditions.append(attr >= val) - elif seq == "<" or (seq == "lt" and val): + elif seq in ("<", "lt") and val is not None: conditions.append(attr < val) - elif seq == "<=" or (seq == "le" and val): + elif seq in ("<=", "le") and val is not None: conditions.append(attr <= val) - elif seq == "==" or (seq == "eq" and val): + elif seq in ("eq", "==") and val is not None: conditions.append(attr == val) else: conditions.append(attr == value) return conditions - def __order_by(self, order_by: builtins.list[dict[str, str]]) -> builtins.list[ColumnElement]: + def _parse_order( + self, order: builtins.list[dict[str, str]] + ) -> builtins.list[ColumnElement]: """ - 获取排序字段 + 解析排序参数 参数: - - order_by (List[Dict[str, str]]): 排序字段列表,格式为 [{'id': 'asc'}, {'name': 'desc'}] + - order: 排序字段列表, 格式为 [{'id': 'asc'}, {'name': 'desc'}] 返回: - - List[ColumnElement]: 排序字段列表 - - 异常: - - CustomException: 排序字段不存在时抛出异常 + - 排序表达式列表 """ - columns = [] - for order in order_by: - for field, direction in order.items(): + columns: builtins.list[ColumnElement] = [] + for item in order: + for field, direction in item.items(): column = getattr(self.model, field) columns.append(desc(column) if direction.lower() == "desc" else asc(column)) return columns @@ -594,33 +619,27 @@ class CRUDBase(Generic[ModelType, CreateSchemaType, UpdateSchemaType]): 构建预加载选项 参数: - - preload (Optional[List[Union[str, Any]]]): 预加载关系，支持关系名字符串或SQLAlchemy loader option + - preload: 预加载关系，支持关系名字符串或 SQLAlchemy loader option 返回: - - List[Any]: 预加载选项列表 + - 预加载选项列表 """ - options = [] - # 获取模型定义的默认加载选项 + options: builtins.list[Any] = [] model_loader_options = getattr(self.model, "__loader_options__", []) - # 合并所有需要预加载的选项 - all_preloads = set(model_loader_options) + all_preloads: set[str | Any] = set(model_loader_options) if preload: for opt in preload: if isinstance(opt, str): all_preloads.add(opt) elif preload == []: - # 如果明确指定空列表，则不使用任何预加载 all_preloads = set() - # 处理所有预加载选项 for opt in all_preloads: if isinstance(opt, str): - # 使用selectinload来避免在异步环境中的MissingGreenlet错误 if hasattr(self.model, opt): options.append(selectinload(getattr(self.model, opt))) else: - # 直接使用非字符串的加载选项 options.append(opt) return options diff --git a/backend/app/core/base_model.py b/backend/app/core/base_model.py index 97982831..5da8088d 100644 --- a/backend/app/core/base_model.py +++ b/backend/app/core/base_model.py @@ -12,6 +12,7 @@ from sqlalchemy.orm import ( ) if TYPE_CHECKING: + from app.api.v1.module_platform.tenant.model import TenantModel from app.api.v1.module_system.user.model import UserModel from app.common.enums import PermissionFilterStrategy @@ -83,11 +84,11 @@ class ModelMixin(MappedBase): comment="UUID全局唯一标识", index=True, ) - status: Mapped[str] = mapped_column( - String(10), - default="0", + status: Mapped[int] = mapped_column( + Integer, + default=0, nullable=False, - comment="状态(0:正常 1:禁用)", + comment="状态", index=True, ) description: Mapped[str | None] = mapped_column( @@ -144,24 +145,20 @@ class TenantMixin(MappedBase): comment="租户ID", ) + @declared_attr + def tenant_by(self) -> Mapped[Optional["TenantModel"]]: + """ + 租户关联关系（延迟加载，避免循环依赖）。 -class TenantAwareMixin(MappedBase): - """ - 租户感知 Mixin（轻量级） - - 与 TenantMixin 不同，本 Mixin 不包含外键约束，tenant_id 可为 NULL。 - 适用于不需要严格引用完整性的场景，或渐进式改造阶段。 - 平台超级管理员在数据层不按租户过滤。 - """ - - __abstract__ = True - - tenant_id: Mapped[int | None] = mapped_column( - Integer, - default=None, - index=True, - comment="租户ID", - ) + 返回: + - Mapped[Optional[TenantModel]]: 租户 ORM 关系。 + """ + return relationship( + "TenantModel", + lazy="selectin", + foreign_keys=lambda: self.tenant_id, # pyright: ignore[reportArgumentType] + uselist=False, + ) class UserMixin(MappedBase): diff --git a/backend/app/core/base_params.py b/backend/app/core/base_params.py index f04c5ee5..f078a84c 100644 --- a/backend/app/core/base_params.py +++ b/backend/app/core/base_params.py @@ -36,9 +36,9 @@ class PaginationQueryParam: self.order_by = json.loads(order_by) except ValueError: # 如果解析失败，使用默认排序 - self.order_by = [{"updated_time": "desc"}] + self.order_by = [{"id": "desc"}] else: - self.order_by = [{"updated_time": "desc"}] + self.order_by = [{"id": "desc"}] class BaseQueryParam: diff --git a/backend/app/core/base_schema.py b/backend/app/core/base_schema.py index d14ff8e8..214810ad 100644 --- a/backend/app/core/base_schema.py +++ b/backend/app/core/base_schema.py @@ -1,7 +1,12 @@ -from pydantic import BaseModel, ConfigDict, Field +from datetime import datetime +from typing import Any, Generic, TypeVar + +from pydantic import BaseModel, ConfigDict, Field, model_validator from app.core.validator import DateTimeStr +T = TypeVar("T") + class CommonSchema(BaseModel): """通用信息模型""" @@ -19,7 +24,7 @@ class BaseSchema(BaseModel): id: int | None = Field(default=None, description="主键ID") uuid: str | None = Field(default=None, description="UUID") - status: str = Field(default="0", description="状态") + status: int = Field(default=0, description="状态") description: str | None = Field(default=None, description="描述") created_time: DateTimeStr | None = Field(default=None, description="创建时间") updated_time: DateTimeStr | None = Field(default=None, description="更新时间") @@ -46,14 +51,14 @@ class TenantBySchema(BaseModel): model_config = ConfigDict(from_attributes=True) tenant_id: int | None = Field(default=None, description="租户ID") - tenant: CommonSchema | None = Field(default=None, description="租户信息") + tenant_by: CommonSchema | None = Field(default=None, description="租户信息") class BatchSetAvailable(BaseModel): """批量设置可用状态的请求模型""" ids: list[int] = Field(default_factory=list, description="ID列表") - status: str = Field(default="0", description="是否可用") + status: int = Field(default=0, ge=0, le=1, description="是否可用") class UploadResponseSchema(BaseModel): @@ -78,3 +83,63 @@ class BatchDelete(BaseModel): """批量删除请求模型""" ids: list[int] = Field(..., min_length=1, description="ID列表") + + +class AuthSchema(BaseModel): + """权限认证模型""" + + model_config = ConfigDict(arbitrary_types_allowed=True) + + user: Any = Field(default=None, description="用户信息", exclude=True) + check_data_scope: bool = Field(default=True, description="是否检查数据权限") + db: Any = Field(default=None, description="数据库会话", exclude=True) + tenant_id: int | None = Field(default=None, description="租户ID,用于用户认证前查询") + + +class JWTPayloadSchema(BaseModel): + """JWT载荷模型""" + + sub: str = Field(..., description="用户登录信息") + is_refresh: bool = Field(default=False, description="是否刷新token") + exp: datetime | int = Field(..., description="过期时间") + + @model_validator(mode="after") + def validate_fields(self): + if not self.sub or len(self.sub.strip()) == 0: + raise ValueError("会话编号不能为空") + return self + + +class JWTOutSchema(BaseModel): + """JWT响应模型""" + + model_config = ConfigDict(from_attributes=True) + + access_token: str = Field(..., min_length=1, description="访问token") + refresh_token: str = Field(..., min_length=1, description="刷新token") + token_type: str = Field(default="Bearer", description="token类型") + expires_in: int = Field(..., gt=0, description="过期时间(秒)") + + +class RefreshTokenPayloadSchema(BaseModel): + """刷新Token载荷模型""" + + refresh_token: str = Field(..., min_length=1, description="刷新token") + + +class LogoutPayloadSchema(BaseModel): + """退出登录载荷模型""" + + token: str = Field(..., min_length=1, description="token") + + +class PageResultSchema(BaseModel, Generic[T]): + """分页查询结果模型""" + + model_config = ConfigDict(from_attributes=True) + + page_no: int | None = Field(default=None, ge=1, description="页码，默认为1") + page_size: int | None = Field(default=None, ge=1, description="页面大小，默认为10") + total: int = Field(default=0, ge=0, description="总记录数") + has_next: bool | None = Field(default=False, description="是否有下一页") + items: list[T] = Field(default_factory=list, description="分页后的数据列表") diff --git a/backend/app/core/context/request_context.py b/backend/app/core/context/request_context.py deleted file mode 100644 index 665458d6..00000000 --- a/backend/app/core/context/request_context.py +++ /dev/null @@ -1,131 +0,0 @@ -"""请求上下文管理 - -为每个请求维护独立的上下文信息（correlation_id、user_id 等）， -通过 Python contextvars 实现异步安全传递。 -""" - -from contextvars import ContextVar, Token -from typing import Any - - -class RequestContext: - """请求级别上下文管理器 - - 使用 contextvars 确保在异步环境中每个请求的上下文独立。 - 典型用法: - ctx = RequestContext() - ctx.set_correlation_id("abc-123") - # 在请求的任何位置（包括异步子协程）都能获取到 - cid = RequestContext.get_correlation_id() - """ - - _correlation_id: ContextVar[str] = ContextVar("correlation_id", default="") - _user_id: ContextVar[int | None] = ContextVar("user_id", default=None) - _tenant_id: ContextVar[int | None] = ContextVar("tenant_id", default=None) - _request_path: ContextVar[str] = ContextVar("request_path", default="") - - @classmethod - def set_correlation_id(cls, correlation_id: str) -> Token: - """设置请求关联 ID - - 参数: - correlation_id: 唯一请求标识，通常从 X-Correlation-ID 请求头获取 - - 返回: - Token: contextvars Token，可用于恢复旧值 - """ - return cls._correlation_id.set(correlation_id) - - @classmethod - def get_correlation_id(cls) -> str: - """获取当前请求的关联 ID - - 如果没有设置则返回空字符串。 - - 返回: - str: 请求关联 ID - """ - return cls._correlation_id.get() - - @classmethod - def set_user_id(cls, user_id: int | None) -> Token: - """设置当前请求的用户 ID - - 参数: - user_id: 用户 ID，None 表示未认证 - - 返回: - Token: contextvars Token - """ - return cls._user_id.set(user_id) - - @classmethod - def get_user_id(cls) -> int | None: - """获取当前请求的用户 ID - - 返回: - Optional[int]: 用户 ID，未认证时返回 None - """ - return cls._user_id.get() - - @classmethod - def set_tenant_id(cls, tenant_id: int | None) -> Token: - """设置当前请求的租户 ID - - 参数: - tenant_id: 租户 ID - - 返回: - Token: contextvars Token - """ - return cls._tenant_id.set(tenant_id) - - @classmethod - def get_tenant_id(cls) -> int | None: - """获取当前请求的租户 ID - - 返回: - Optional[int]: 租户 ID - """ - return cls._tenant_id.get() - - @classmethod - def set_request_path(cls, path: str) -> Token: - """设置当前请求路径 - - 参数: - path: 请求路径 - - 返回: - Token: contextvars Token - """ - return cls._request_path.set(path) - - @classmethod - def get_request_path(cls) -> str: - """获取当前请求路径 - - 返回: - str: 请求路径 - """ - return cls._request_path.get() - - @classmethod - def get_extra_fields(cls) -> dict[str, Any]: - """获取日志附加字段 - - 将所有上下文信息组装为字典，用于日志输出。 - - 返回: - dict: 包含 correlation_id、user_id、tenant_id 的字典 - """ - fields: dict[str, Any] = { - "correlation_id": cls.get_correlation_id(), - } - user_id = cls.get_user_id() - if user_id is not None: - fields["user_id"] = user_id - tenant_id = cls.get_tenant_id() - if tenant_id is not None: - fields["tenant_id"] = tenant_id - return fields diff --git a/backend/app/core/database.py b/backend/app/core/database.py index f6336776..b6d2d744 100644 --- a/backend/app/core/database.py +++ b/backend/app/core/database.py @@ -13,7 +13,7 @@ from sqlalchemy.orm import sessionmaker from app.config.setting import settings from app.core.base_model import MappedBase from app.core.exceptions import CustomException -from app.core.logger import log +from app.core.logger import logger def create_engine_and_session( @@ -42,7 +42,7 @@ def create_engine_and_session( pool_recycle=settings.POOL_RECYCLE, ) except Exception as e: - log.error(f"❌ 数据库连接失败 {e}") + logger.error(f"❌ 数据库连接失败 {e}") raise else: # 同步数据库会话工厂 @@ -92,7 +92,7 @@ def create_async_engine_and_session( pool_use_lifo=settings.POOL_USE_LIFO, ) except Exception as e: - log.error(f"❌ 数据库连接失败 {e}") + logger.error(f"❌ 数据库连接失败 {e}") raise else: # 异步数据库会话工厂 @@ -163,14 +163,14 @@ async def redis_connect(app: FastAPI, status: bool) -> Redis | None: if await rd.ping(): # pyright: ignore[reportGeneralTypeIssues] return rd except exceptions.AuthenticationError as e: - log.error(f"❌ 数据库 Redis 认证失败: {e}") + logger.error(f"❌ 数据库 Redis 认证失败: {e}") raise except exceptions.TimeoutError as e: - log.error(f"❌ 数据库 Redis 连接超时: {e}") + logger.error(f"❌ 数据库 Redis 连接超时: {e}") raise except exceptions.RedisError as e: - log.error(f"❌ 数据库 Redis 连接错误: {e}") + logger.error(f"❌ 数据库 Redis 连接错误: {e}") raise else: await app.state.redis.close() - log.info("✅️ Redis连接已关闭") + logger.info("✅️ Redis连接已关闭") diff --git a/backend/app/core/dependencies.py b/backend/app/core/dependencies.py index 4c12c4be..dceafe44 100644 --- a/backend/app/core/dependencies.py +++ b/backend/app/core/dependencies.py @@ -1,38 +1,32 @@ import json +import time from collections.abc import AsyncGenerator from fastapi import Depends, Query, Request from redis.asyncio.client import Redis +from sqlalchemy import select from sqlalchemy.ext.asyncio import AsyncSession from sqlalchemy.orm import selectinload -from app.core.auth_schema import AuthSchema from app.common.enums import RedisInitKeyConfig from app.config.setting import settings +from app.core.base_schema import AuthSchema from app.core.database import async_db_session from app.core.exceptions import CustomException -from app.core.logger import log +from app.core.logger import logger from app.core.redis_crud import RedisCURD from app.core.security import OAuth2Schema, decode_access_token from app.core.tenant import get_current_tenant_id as _get_ctx_tenant_id -from app.core.tenant import set_current_tenant - -async def db_getter_read() -> AsyncGenerator[AsyncSession, None]: - """只读数据库会话 — 无事务开销，适用于纯 SELECT 查询。 - - 比 db_getter 少一次 BEGIN/ROLLBACK 网络往返， - 每次只读请求可省约 2 次 TCP 往返。 - """ - async with async_db_session() as session: - yield session +# 套餐菜单权限缓存: {tenant_id: (timestamp, [menu_ids])} +_package_menu_cache: dict[int, tuple[float, list[int]]] = {} async def db_getter() -> AsyncGenerator[AsyncSession, None]: - """读写数据库会话 — 带显式事务，适用于 INSERT/UPDATE/DELETE。 + """数据库会话 — 请求级生命周期管理。 - 返回: - - AsyncSession: 数据库会话连接 + 一个 HTTP 请求内所有写入共享同一个事务，要么全成功，要么全失败。 + 自动提交（无异常时）或回滚（异常时）。 """ async with async_db_session() as session: async with session.begin(): @@ -63,58 +57,61 @@ async def get_current_tenant_id() -> int | None: return _get_ctx_tenant_id() -async def get_current_user( - request: Request, - db: AsyncSession = Depends(db_getter), - redis: Redis = Depends(redis_getter), - token: str = Depends(OAuth2Schema), -) -> AuthSchema: - """获取当前用户 +# ── Token 解析 & 验证辅助函数 ── + + +def _decode_token_info(token: str) -> tuple[dict, str]: + """解码 JWT token 返回 (user_info, session_id) 参数: - - request (Request): 请求对象 - - db (AsyncSession): 数据库会话 - - redis (Redis): Redis连接 - - token (str): 访问令牌 + token: JWT token 字符串 返回: - - AuthSchema: 认证信息模型 + (user_info, session_id): 用户信息字典和会话 ID """ - # 延迟导入避免循环依赖 - from app.api.v1.module_system.user.crud import UserCRUD - from app.api.v1.module_system.user.model import UserModel - - if not token: - raise CustomException(msg="认证已失效", code=10401, status_code=401) - - # 处理Bearer token - if token.startswith("Bearer"): - token = token.split(" ")[1] - payload = decode_access_token(token) if not payload or not hasattr(payload, "is_refresh") or payload.is_refresh: raise CustomException(msg="非法凭证", code=10401, status_code=401) online_user_info = payload.sub - # 从Redis中获取用户信息 - # online_user_info可能已经是字典类型，需要先判断 user_info = ( online_user_info if isinstance(online_user_info, dict) else json.loads(online_user_info) ) - session_id = user_info.get("session_id") if not session_id: raise CustomException(msg="认证已失效", code=10401, status_code=401) - # 检查用户是否在线 + return user_info, session_id + + +async def _check_token_online(redis: Redis, session_id: str) -> None: + """检查 token 是否在线（Redis 中存在对应 session） + + 参数: + redis: Redis 连接 + session_id: 会话 ID + """ online_ok = await RedisCURD(redis).exists( key=f"{RedisInitKeyConfig.ACCESS_TOKEN.key}:{session_id}" ) if not online_ok: raise CustomException(msg="认证已失效", code=10401, status_code=401) - # 如果启用了滑动过期，自动续期token - if settings.TOKEN_SLIDING_EXPIRE: + +async def _try_sliding_refresh(redis: Redis, session_id: str) -> None: + """滑动过期续期（仅在 token 剩余不足一半时触发） + + 参数: + redis: Redis 连接 + session_id: 会话 ID + """ + if not settings.TOKEN_SLIDING_EXPIRE: + return + + ttl = await RedisCURD(redis).ttl( + key=f"{RedisInitKeyConfig.ACCESS_TOKEN.key}:{session_id}" + ) + if ttl > 0 and ttl < settings.ACCESS_TOKEN_EXPIRE_MINUTES // 2: await RedisCURD(redis).expire( key=f"{RedisInitKeyConfig.ACCESS_TOKEN.key}:{session_id}", expire=settings.ACCESS_TOKEN_EXPIRE_MINUTES, @@ -124,41 +121,124 @@ async def get_current_user( expire=settings.REFRESH_TOKEN_EXPIRE_MINUTES, ) - # 关闭数据权限过滤（角色权限依赖用户对象，此时尚未加载） - # 租户隔离通过 tenant_id 单独控制，不依赖 check_data_scope - tenant_id = user_info.get("tenant_id") - is_super_admin = user_info.get("is_super_admin", False) - # 设置租户上下文（供 ORM 过滤器及下游代码使用） - set_current_tenant(tenant_id, is_super_admin) - auth = AuthSchema(db=db, tenant_id=tenant_id, check_data_scope=False) - username = user_info.get("user_name") - if not username: - raise CustomException(msg="认证已失效", code=10401, status_code=401) - # 获取用户信息，使用深层预加载确保RoleModel.creator被正确加载 - user = await UserCRUD(auth).get_by_username_crud( - username=username, - preload=[ - "dept", - selectinload(UserModel.roles), - "positions", - "created_by", - ], + +# ── 用户加载辅助函数 ── + + +async def _load_user_from_db(db: AsyncSession, username: str): + """从数据库加载用户（含角色、菜单、部门、职位全量预加载） + + 使用原始查询以绕过 CRUDBase 的权限过滤，确保用户认证阶段不受数据权限影响。 + 所有关系链均 eager-loaded，调用方可在会话关闭后安全访问对象属性。 + + 参数: + db: 数据库会话 + username: 用户名 + + 返回: + UserModel: 已全量加载的用户 ORM 对象 + """ + from app.api.v1.module_system.role.model import RoleModel + from app.api.v1.module_system.user.model import UserModel + + stmt = ( + select(UserModel) + .options( + selectinload(UserModel.dept), + selectinload(UserModel.roles).selectinload(RoleModel.menus), + selectinload(UserModel.positions), + selectinload(UserModel.created_by), + ) + .where(UserModel.username == username, UserModel.is_deleted == False) # noqa: E712 ) + result = await db.execute(stmt) + user = result.scalars().first() if not user: raise CustomException(msg="用户不存在", code=10401, status_code=401) - if user.status == "1": + if user.status == 1: raise CustomException(msg="用户已被停用", code=10401, status_code=401) - # 设置请求上下文 - request.scope["user_id"] = user.id - request.scope["user_username"] = user.username - - # 过滤可用的角色和职位 + # 过滤不可用的角色和职位（在会话内完成，确保关联数据已加载） if hasattr(user, "roles"): user.roles = [role for role in user.roles if role and role.status] if hasattr(user, "positions"): user.positions = [pos for pos in user.positions if pos and pos.status] + return user + + +# ── 依赖注入函数 ── + + +async def get_current_user( + request: Request, + db: AsyncSession = Depends(db_getter), + redis: Redis = Depends(redis_getter), + token: str = Depends(OAuth2Schema), +) -> AuthSchema: + """获取当前用户 + + 用户查询使用独立的只读数据库会话（不参与请求事务，查询完成后立即释放快照）， + 返回的 auth.db 指向请求级事务会话供后续写操作使用。 + + 参数: + - request (Request): 请求对象 + - db (AsyncSession): 请求级事务会话 + - redis (Redis): Redis连接 + - token (str): 访问令牌 + + 返回: + - AuthSchema: 认证信息模型 + """ + if not token: + raise CustomException(msg="认证已失效", code=10401, status_code=401) + + # 处理Bearer token + if token.startswith("Bearer"): + token = token.split(" ")[1] + + # 优先使用 TenantMiddleware 缓存在 scope 中的 JWT 解码结果（避免重复解码） + cached_payload = request.scope.get("_jwt_payload") + cached_user_info = request.scope.get("_jwt_user_info") + + if cached_payload and cached_user_info: + payload = cached_payload + user_info = cached_user_info + else: + payload = decode_access_token(token) + if not payload or not hasattr(payload, "is_refresh") or payload.is_refresh: + raise CustomException(msg="非法凭证", code=10401, status_code=401) + + online_user_info = payload.sub + user_info = ( + online_user_info if isinstance(online_user_info, dict) else json.loads(online_user_info) + ) + + session_id = user_info.get("session_id") + if not session_id: + raise CustomException(msg="认证已失效", code=10401, status_code=401) + + # Redis 在线检查 + 滑动续期 + await _check_token_online(redis, session_id) + await _try_sliding_refresh(redis, session_id) + + username = user_info.get("user_name") + if not username: + raise CustomException(msg="认证已失效", code=10401, status_code=401) + tenant_id = user_info.get("tenant_id") + + # 用户查询使用独立只读会话（不参与请求事务，查询后立即释放快照） + async with async_db_session() as lookup_db: + user = await _load_user_from_db(lookup_db, username) + + # 设置请求上下文 + request.scope["user_id"] = user.id + request.scope["user_username"] = user.username + request.scope["session_id"] = session_id + request.scope["session_info"] = user_info + + # 返回的 auth.db 指向请求级事务会话，供后续读写操作使用 + auth = AuthSchema(db=db, tenant_id=tenant_id, check_data_scope=False) auth.user = user return auth @@ -186,7 +266,7 @@ async def _verify_token( db: AsyncSession, redis: Redis, ) -> AuthSchema: - """验证token并返回用户信息 + """验证token并返回用户信息（共享核心逻辑） 参数: - token (str): 认证token @@ -196,10 +276,6 @@ async def _verify_token( 返回: - AuthSchema: 认证信息模型 """ - # 延迟导入避免循环依赖 - from app.api.v1.module_system.user.crud import UserCRUD - from app.api.v1.module_system.user.model import UserModel - if not token: raise CustomException(msg="认证已失效", code=10401, status_code=401) @@ -207,77 +283,51 @@ async def _verify_token( if token.startswith("Bearer"): token = token.split(" ")[1] - payload = decode_access_token(token) - if not payload or not hasattr(payload, "is_refresh") or payload.is_refresh: - raise CustomException(msg="非法凭证", code=10401, status_code=401) + user_info, session_id = _decode_token_info(token) + await _check_token_online(redis, session_id) + await _try_sliding_refresh(redis, session_id) - online_user_info = payload.sub - # 从Redis中获取用户信息 - # online_user_info可能已经是字典类型，需要先判断 - user_info = ( - online_user_info if isinstance(online_user_info, dict) else json.loads(online_user_info) - ) - - session_id = user_info.get("session_id") - if not session_id: - raise CustomException(msg="认证已失效", code=10401, status_code=401) - - # 检查用户是否在线 - online_ok = await RedisCURD(redis).exists( - key=f"{RedisInitKeyConfig.ACCESS_TOKEN.key}:{session_id}" - ) - if not online_ok: - raise CustomException(msg="认证已失效", code=10401, status_code=401) - - # 如果启用了滑动过期，自动续期token - if settings.TOKEN_SLIDING_EXPIRE: - await RedisCURD(redis).expire( - key=f"{RedisInitKeyConfig.ACCESS_TOKEN.key}:{session_id}", - expire=settings.ACCESS_TOKEN_EXPIRE_MINUTES, - ) - await RedisCURD(redis).expire( - key=f"{RedisInitKeyConfig.REFRESH_TOKEN.key}:{session_id}", - expire=settings.REFRESH_TOKEN_EXPIRE_MINUTES, - ) - - # 设置租户上下文（供 ORM 过滤器使用） - tenant_id = user_info.get("tenant_id") - is_super_admin = user_info.get("is_super_admin", False) - set_current_tenant(tenant_id, is_super_admin) - # 关闭数据权限过滤，避免当前用户查询被拦截 - auth = AuthSchema(db=db, check_data_scope=False) username = user_info.get("user_name") if not username: raise CustomException(msg="认证已失效", code=10401, status_code=401) - # 获取用户信息，使用深层预加载确保RoleModel.creator被正确加载 - user = await UserCRUD(auth).get_by_username_crud( - username=username, - preload=[ - "dept", - selectinload(UserModel.roles), - "positions", - "created_by", - ], - ) - if not user: - raise CustomException(msg="用户不存在", code=10401, status_code=401) - if user.status == "1": - raise CustomException(msg="用户已被停用", code=10401, status_code=401) + tenant_id = user_info.get("tenant_id") - # 设置请求上下文 - # request.scope["user_id"] = user.id - # request.scope["user_username"] = user.username - - # 过滤可用的角色和职位 - if hasattr(user, "roles"): - user.roles = [role for role in user.roles if role and role.status] - if hasattr(user, "positions"): - user.positions = [pos for pos in user.positions if pos and pos.status] + user = await _load_user_from_db(db, username) + auth = AuthSchema(db=db, tenant_id=tenant_id, check_data_scope=False) auth.user = user return auth +# ── 套餐菜单缓存 ── + + +async def _get_cached_tenant_menu_ids(auth: AuthSchema, tenant_id: int) -> list[int]: + """获取租户可用菜单 ID，带 60s 进程级缓存 + + 套餐菜单变更频率极低，缓存可大幅减少 AuthPermission 的 DB 查询次数。 + + 参数: + auth: 认证信息 + tenant_id: 租户 ID + + 返回: + 可用菜单 ID 列表 + """ + cached = _package_menu_cache.get(tenant_id) + if cached and time.time() - cached[0] < 60: + return cached[1] + + from app.api.v1.module_platform.package.service import PackageService + + result = await PackageService.get_tenant_available_menu_ids(auth, tenant_id) + _package_menu_cache[tenant_id] = (time.time(), result) + return result + + +# ── 权限验证类 ── + + class AuthPermission: """权限验证类""" @@ -324,17 +374,28 @@ class AuthPermission: if not auth.user or not auth.user.roles: raise CustomException(msg="无权限操作", code=10403, status_code=403) - # 获取用户权限集合 - user_permissions = { - menu.permission - for role in auth.user.roles - for menu in role.menus - if role.status == "0" and menu.permission and menu.status == "0" - } + # 收集角色权限（附带 menu_id 用于套餐过滤） + role_perms: dict[str, int] = {} + for role in auth.user.roles: + if role.status != 0: + continue + for menu in role.menus: + if menu.status == 0 and menu.permission: + role_perms[menu.permission] = menu.id + + if not role_perms: + raise CustomException(msg="无权限操作", code=10403, status_code=403) + + # 租户用户：权限必须受套餐菜单约束（带 60s 进程级缓存） + if auth.tenant_id: + allowed_ids = set(await _get_cached_tenant_menu_ids(auth, auth.tenant_id)) + user_permissions = {p for p, mid in role_perms.items() if mid in allowed_ids} + else: + user_permissions = set(role_perms.keys()) # 权限验证 - 满足任一权限即可 if not any(perm in user_permissions for perm in self.permissions): - log.error(f"用户缺少任何所需的权限: {self.permissions}") + logger.error(f"用户缺少任何所需的权限: {self.permissions}") raise CustomException(msg="无权限操作", code=10403, status_code=403) return auth diff --git a/backend/app/core/di.py b/backend/app/core/di.py deleted file mode 100644 index 885b417b..00000000 --- a/backend/app/core/di.py +++ /dev/null @@ -1,45 +0,0 @@ -"""依赖注入容器 - -使用 dependency-injector 管理应用依赖，为后续 Repository 模式迁移提供基础。 - -当前状态：容器框架已搭建，但现有代码仍可直接使用 CRUDBase。 -Phase 2 将逐步迁移 Service 层使用容器注入的 Repository。 - -用法: - from app.core.di import container - - # 通过容器获取依赖 - event_bus = container.event_bus() -""" - -from dependency_injector import containers, providers - -from app.config.setting import get_settings - - -class ApplicationContainer(containers.DeclarativeContainer): - """全局依赖注入容器 - - 管理应用的各层依赖： - - 配置 - - 基础设施（Redis、数据库会话由 FastAPI Depends 管理） - - Repository（Phase 2 实现） - - Domain Services（Phase 3 实现） - """ - - # ==================== 配置 ==================== - config = providers.Singleton(get_settings) - - # ==================== 基础设施（待后续 Phase 启用） ==================== - # redis_client = providers.Singleton(RedisClient) - # cache_manager = providers.Singleton(CacheManager, redis=redis_client) - # event_bus = providers.Singleton(EventBus) - # task_queue = providers.Singleton(TaskQueue) - - # ==================== Repository（Phase 2 实现） ==================== - # user_repository = providers.Factory(UserRepositoryImpl) - # role_repository = providers.Factory(RoleRepositoryImpl) - - -# 全局容器单例 -container = ApplicationContainer() diff --git a/backend/app/core/discover.py b/backend/app/core/discover.py index 86f1237b..87eb0ca0 100644 --- a/backend/app/core/discover.py +++ b/backend/app/core/discover.py @@ -1,12 +1,12 @@ """ -简化的动态路由发现与注册 +简化的动态路由发现与注册。 目录与命名规范（不满足则无法注册或导入失败）： - 插件必须放在 ``app/plugin`` 下，且**顶级目录名**必须以 ``module_`` 开头，例如 ``module_example``、``module_yourfeature``（扫描模式：``module_*/**/controller.py``）。 - 控制器文件名必须为 ``controller.py``（大小写敏感，Linux 上 ``Controller.py`` 无效）。 - 从 ``module_xxx`` 到 ``controller.py`` 的**每一级目录名**须为合法 Python 标识符 - （仅字母数字下划线、不以数字开头；不要使用中划线、空格、中文目录名等）。 + （仅字母数字下划线、不以数字开头；不要使用中划线、空格、中文目录名等）。 - 每一级目录应可作为包导入：通常需有 ``__init__.py``（或符合 namespace package 规则）。 - 在 ``controller.py`` 的**模块顶层**定义 ``APIRouter`` 实例并赋值给变量 （如 ``DemoRouter = APIRouter(...)``）；定义在函数内部的 router **不会被**扫描到。 @@ -21,13 +21,197 @@ # 标准库导入 import importlib +import sys from pathlib import Path # 第三方库导入 -from fastapi import APIRouter +from fastapi import APIRouter, Depends +from fastapi import FastAPI as _FastAPI # 内部库导入 -from app.core.logger import log +from app.core.logger import logger + +# 模块级缓存：最近一次构建的动态路由实例 +_dynamic_router_cache: APIRouter | None = None +# 记录最近一次注册到 app 的插件路径前缀，用于热重载时精准移除 +_registered_plugin_prefixes: set[str] = set() +# 运行时引用，由 init_app.py 设置 +_app_ref: _FastAPI | None = None + + +def set_app_ref(app: _FastAPI) -> None: + """由 init_app.py 在 app 创建后调用，存储引用供热重载使用。""" + global _app_ref + _app_ref = app + + +def _build_dynamic_router() -> APIRouter: + """实际执行扫描，返回新的动态路由 APIRouter 实例。""" + logger.info("🚀 开始动态路由发现与注册") + + root_router = APIRouter() + seen_router_ids: set[int] = set() + try: + base_package = importlib.import_module("app.plugin") + base_dir = Path(next(iter(base_package.__path__))) + + controller_files = list(base_dir.glob("module_*/**/controller.py")) + controller_files.sort() + + container_routers: dict[str, APIRouter] = {} + + for file in controller_files: + rel_path = file.relative_to(base_dir) + path_parts = rel_path.parts + top_module = path_parts[0] + + suffix = top_module[7:] if top_module.startswith("module_") else "" + if not suffix: + logger.error( + f"❌ 跳过异常顶级目录名（须为 module_ 前缀且后面还有名称）: {top_module!r}，" + f"文件: {file}" + ) + continue + prefix = f"/{suffix}" + + if prefix not in container_routers: + container_routers[prefix] = APIRouter(prefix=prefix) + container_router = container_routers[prefix] + + module_path = f"app.plugin.{'.'.join(path_parts[:-1])}.controller" + try: + module = importlib.import_module(module_path) + registered_here = 0 + for attr_name in dir(module): + attr_value = getattr(module, attr_name, None) + if isinstance(attr_value, APIRouter): + router_id = id(attr_value) + if router_id not in seen_router_ids: + seen_router_ids.add(router_id) + container_router.include_router(attr_value) + registered_here += 1 + logger.info(f" ↳ 注册 APIRouter 变量 `{attr_name}` ← {module_path}") + + if registered_here == 0: + logger.warning( + f"⚠️ 模块已加载但未注册任何路由: {module_path}\n" + f" 原因：该文件中未找到**顶层** APIRouter 实例。\n" + f" 规范：在 controller.py 模块顶层定义，例如 " + f"`XxxRouter = APIRouter(route_class=..., prefix=..., tags=[...])`，" + f"不要仅在函数内创建 APIRouter。" + ) + + except Exception as e: + hint = _import_failure_hint(e) + logger.error(f"❌ 处理模块失败: {module_path}\n {hint}\n 异常: {e!s}") + + for prefix, container_router in sorted(container_routers.items()): + route_count = len(container_router.routes) + root_router.include_router(container_router) + if route_count == 0: + logger.warning( + f"⚠️ 容器前缀 {prefix} 下未挂载任何子路由（可能该 module 下所有 controller 均未导出 APIRouter）" + ) + logger.info(f"✅ 注册容器: {prefix} (子路由数: {route_count})") + + # 记录本次注册的所有插件前缀，供热重载时精准移除 + global _registered_plugin_prefixes + _registered_plugin_prefixes = set(container_routers.keys()) + + logger.info(f"✅ 动态路由发现完成: 共 {len(container_routers)} 个容器前缀") + return root_router + + except Exception as e: + logger.error(f"❌ 动态路由发现整体失败: {e!s}") + return root_router + + +def get_dynamic_router() -> APIRouter: + """ + 获取动态路由实例（带缓存）。 + + 返回: + - APIRouter: 包含所有动态路由的根路由实例 + """ + global _dynamic_router_cache + if _dynamic_router_cache is None: + _dynamic_router_cache = _build_dynamic_router() + return _dynamic_router_cache + + +def reload_dynamic_router() -> APIRouter: + """ + 清除插件模块缓存并重新扫描，同时更新已挂载到 FastAPI app 的路由。 + + 工作机制： + 1. 根据 _registered_plugin_prefixes 精准移除 app.routes 中已注册的插件路由 + 2. 清除 sys.modules 中缓存的插件模块 + 3. 重新扫描并构建新的动态路由 + 4. 将新路由挂载回 app（include_router） + + 要求：init_app.py 在创建 app 后调用 discover.set_app_ref(app)， + 否则路由重载仅重建 Router 对象，不会更新运行中的 app。 + + 返回: + - APIRouter: 重新构建后的动态路由实例 + """ + global _dynamic_router_cache, _registered_plugin_prefixes, _app_ref + + app = _app_ref + rate_deps = [] + + # ── 1. 从运行中的 app 移除旧的插件路由 ── + if app and _registered_plugin_prefixes: + before = len(app.routes) + app.routes = [ + r for r in app.routes + if not any( + getattr(r, "path", "").startswith(p) + for p in _registered_plugin_prefixes + ) + ] + removed = before - len(app.routes) + logger.info(f"🧹 已移除 {removed} 条旧插件路由（前缀: {_registered_plugin_prefixes}）") + elif not app: + logger.warning("⚠️ _app_ref 未设置，无法更新运行中的 app 路由；请确认 init_app.py 已调用 discover.set_app_ref(app)") + + # ── 2. 清除插件模块缓存，迫使 importlib 重新执行模块代码 ── + _purge_plugin_modules() + + # ── 3. 重新扫描并构建 ── + _dynamic_router_cache = _build_dynamic_router() + + # ── 4. 将新路由挂载回 app ── + if app: + # 构造与 init_app.py 中相同的依赖项 + try: + from fastapi_limiter.depends import RateLimiter + rate_deps = [Depends(RateLimiter(times=200, seconds=10))] + except Exception: + rate_deps = [] + app.include_router(_dynamic_router_cache, dependencies=rate_deps) + logger.info("✅ 新插件路由已挂载到运行中的 app") + + logger.info("✅ 插件动态路由热重载完成") + return _dynamic_router_cache + + +def _purge_plugin_modules() -> None: + """ + 从 sys.modules 中清除所有 app.plugin.module_* 模块， + 使下一次 importlib.import_module 时重新执行模块代码。 + """ + prefix = "app.plugin.module_" + purged: list[str] = [] + for mod_name in list(sys.modules): + if mod_name.startswith(prefix): + del sys.modules[mod_name] + purged.append(mod_name) + + if purged: + logger.info(f"🧹 已清除 {len(purged)} 个插件模块缓存，将重新导入") + else: + logger.info("🧹 未发现需要清除的插件模块缓存") def _import_failure_hint(exc: BaseException) -> str: @@ -59,111 +243,5 @@ def _import_failure_hint(exc: BaseException) -> str: ) -def get_dynamic_router() -> APIRouter: - """ - 执行动态路由发现与注册，返回包含所有动态路由的根路由实例 - - 返回: - - APIRouter: 包含所有动态路由的根路由实例 - """ - log.info("🚀 开始动态路由发现与注册") - - # 创建根路由实例 - root_router = APIRouter() - - # 已注册的路由ID集合，用于避免重复注册 - seen_router_ids: set[int] = set() - - try: - # 获取app.plugin包的路径 - base_package = importlib.import_module("app.plugin") - base_dir = Path(next(iter(base_package.__path__))) - - # 查找所有符合条件的controller.py文件 - # 只扫描module_*目录下的文件 - controller_files = list(base_dir.glob("module_*/**/controller.py")) - - # 按路径排序，确保注册顺序一致 - controller_files.sort() - - # 容器路由映射 {prefix: container_router} - container_routers: dict[str, APIRouter] = {} - - for file in controller_files: - # 解析文件路径 - rel_path = file.relative_to(base_dir) - path_parts = rel_path.parts - - # 获取顶级模块名 - top_module = path_parts[0] - - # 生成路由前缀 (module_xxx -> /xxx) - suffix = top_module[7:] if top_module.startswith("module_") else "" - if not suffix: - log.error( - f"❌ 跳过异常顶级目录名（须为 module_ 前缀且后面还有名称）: {top_module!r}，" - f"文件: {file}" - ) - continue - prefix = f"/{suffix}" - - # 获取或创建容器路由 - if prefix not in container_routers: - container_routers[prefix] = APIRouter(prefix=prefix) - container_router = container_routers[prefix] - - # 生成模块导入路径 - module_path = f"app.plugin.{'.'.join(path_parts[:-1])}.controller" - - try: - # 动态导入模块 - module = importlib.import_module(module_path) - - # 查找并注册所有APIRouter实例 - registered_here = 0 - for attr_name in dir(module): - attr_value = getattr(module, attr_name, None) - - # 只注册APIRouter实例，且避免重复注册 - if isinstance(attr_value, APIRouter): - router_id = id(attr_value) - if router_id not in seen_router_ids: - seen_router_ids.add(router_id) - container_router.include_router(attr_value) - registered_here += 1 - log.debug(f" ↳ 注册 APIRouter 变量 `{attr_name}` ← {module_path}") - - if registered_here == 0: - log.warning( - f"⚠️ 模块已加载但未注册任何路由: {module_path}\n" - f" 原因：该文件中未找到**顶层** APIRouter 实例。\n" - f" 规范：在 controller.py 模块顶层定义，例如 " - f"`XxxRouter = APIRouter(route_class=..., prefix=..., tags=[...])`，" - f"不要仅在函数内创建 APIRouter。" - ) - - except Exception as e: - hint = _import_failure_hint(e) - log.exception(f"❌ 处理模块失败: {module_path}\n {hint}\n 异常: {e!s}") - - # 将所有容器路由注册到根路由 - for prefix, container_router in sorted(container_routers.items()): - route_count = len(container_router.routes) - root_router.include_router(container_router) - if route_count == 0: - log.warning( - f"⚠️ 容器前缀 {prefix} 下未挂载任何子路由（可能该 module 下所有 controller 均未导出 APIRouter）" - ) - log.info(f"✅️ 注册容器: {prefix} (子路由数: {route_count})") - - log.info(f"✅️ 动态路由发现完成: 共 {len(container_routers)} 个容器前缀") - return root_router - - except Exception as e: - log.exception(f"❌ 动态路由发现整体失败: {e!s}") - # 如果失败，返回一个空的路由实例 - return root_router - - # 重新导出函数供外部使用 -__all__ = ["get_dynamic_router"] +__all__ = ["get_dynamic_router", "reload_dynamic_router"] diff --git a/backend/app/core/docs.py b/backend/app/core/docs.py deleted file mode 100644 index b41b5818..00000000 --- a/backend/app/core/docs.py +++ /dev/null @@ -1,88 +0,0 @@ -from typing import Annotated - -from starlette.responses import HTMLResponse -from typing_extensions import Doc - - -def get_custom_ui_html( - *, - openapi_url: Annotated[ - str, - Doc( - """ - The OpenAPI URL that Swagger UI should load and use. - - This is normally done automatically by FastAPI using the default URL - `/openapi.json`. - """ - ), - ], - title: Annotated[ - str, - Doc( - """ - The HTML `