sync

* Add multiple database data source config

* Fix comments

* Fix deploy env

.dockerignore

@@ -3,7 +3,11 @@ __pycache__/
 .github/
 .idea/
 .vscode/
+.cursor/
 venv/
 .venv/
 .ruff_cache/
 .pytest_cache/
+.claude/
+.serena/
+.logs/

.github/workflows/changelog.yml

@@ -1,16 +1,18 @@
 name: Release changelog
 
 on:
-  push:
+  workflow_run:
-    tags:
+    workflows: ['Check version']
-      - v*
+    types:
+      - completed
 
 jobs:
   changelog:
     runs-on: ubuntu-latest
+    if: ${{ github.event.workflow_run.conclusion == 'success' }}
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v6
         with:
           ref: master
 

.github/workflows/lint.yml

@@ -15,10 +15,10 @@ jobs:
         python-version: [ '3.10', '3.11', '3.12', '3.13', '3.14' ]
       fail-fast: false
     steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v6
 
       - name: Install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v7
 
       - name: Set up Python ${{ matrix.python-version }}
         run: uv python install ${{ matrix.python-version }}

.github/workflows/version.yml

@@ -0,0 +1,25 @@
+name: Check version
+
+on:
+  push:
+    tags:
+      - v*
+
+jobs:
+  check-version:
+    name: check version
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/')
+    steps:
+      - uses: actions/checkout@v6
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v7
+
+      - name: Set up Python
+        run: uv python install 3.13
+
+      - name: Check the package version
+        uses: samuelcolvin/check-python-version@v5
+        with:
+          version_file_path: backend/__init__.py

.gitignore

@@ -7,4 +7,11 @@ venv/
 .python-version
 .ruff_cache/
 .pytest_cache/
+logs/
 .claude/
+.serena/
+.agents/
+.superpowers/
+superpowers/
+.codegraph/
+.pi/

.pre-commit-config.yaml

@@ -10,8 +10,16 @@ repos:
       - id: check-yaml
       - id: check-toml
 
+  - repo: https://github.com/tombi-toml/tombi-pre-commit
+    rev: v1.3.0
+    hooks:
+      - id: tombi-lint
+        args: ["--offline"]
+      - id: tombi-format
+        args: ["--offline"]
+
   - repo: https://github.com/charliermarsh/ruff-pre-commit
-    rev: v0.14.6
+    rev: v0.16.3
     hooks:
       - id: ruff-check
         args:
@@ -21,7 +29,7 @@ repos:
       - id: ruff-format
 
   - repo: https://github.com/astral-sh/uv-pre-commit
-    rev: 0.9.12
+    rev: 0.12.3
     hooks:
       - id: uv-lock
       - id: uv-export

.ruff.toml

@@ -1,174 +0,0 @@
-line-length = 120
-preview = true
-fix = true
-unsafe-fixes = true
-show-fixes = true
-required-version = ">=0.13.0"
-
-[lint]
-select = [
-    "FAST",
-    "ANN001",
-    "ANN201",
-    "ANN202",
-    "ANN204",
-    "ANN205",
-    "ANN206",
-    "ASYNC110",
-    "ASYNC116",
-    "ASYNC210",
-    "ASYNC212",
-    "ASYNC230",
-    "ASYNC240",
-    "ASYNC250",
-    "ASYNC251",
-    "S310",
-    "FBT001",
-    "FBT002",
-    "B002",
-    "B005",
-    "B006",
-    "B007",
-    "B008",
-    "B009",
-    "B010",
-    "B013",
-    "B014",
-    "B019",
-    "B020",
-    "B021",
-    "B024",
-    "B025",
-    "B026",
-    "B027",
-    "B039",
-    "COM",
-    "C402",
-    "C403",
-    "C404",
-    "C408",
-    "C410",
-    "C411",
-    "C414",
-    "C416",
-    "C417",
-    "C418",
-    "C419",
-    "C420",
-    "DTZ",
-    "EXE",
-    "ISC001",
-    "ISC002",
-    "ISC003",
-    "PIE",
-    "PYI009",
-    "PYI010",
-    "PYI011",
-    "PYI012",
-    "PYI013",
-    "PYI016",
-    "PYI017",
-    "PYI019",
-    "PYI020",
-    "PYI021",
-    "PYI024",
-    "PYI026",
-    "PYI030",
-    "PYI033",
-    "PYI034",
-    "PYI036",
-    "PYI041",
-    "PYI042",
-    "PYI055",
-    "PYI061",
-    "PYI062",
-    "PYI063",
-    "Q001",
-    "Q002",
-    "RSE102",
-    "RET501",
-    "RET505",
-    "RET506",
-    "RET507",
-    "RET508",
-    "SIM101",
-    "SIM102",
-    "SIM103",
-    "SIM107",
-    "SIM108",
-    "SIM109",
-    "SIM110",
-    "SIM114",
-    "SIM115",
-    "SIM201",
-    "SIM202",
-    "SIM210",
-    "SIM211",
-    "SIM212",
-    "SIM300",
-    "SIM401",
-    "SIM910",
-    "TID252",
-    "TC",
-    "FLY",
-    "I",
-    "C901",
-    "N",
-    "PERF",
-    "E",
-    "W",
-    "D404",
-    "D417",
-    "D419",
-    "F",
-    "PGH",
-    "PLC1901",
-    "UP",
-    "FURB",
-    "RUF",
-    "TRY",
-]
-ignore = [
-    "COM812",
-    "PGH003",
-    "RUF001",
-    "RUF002",
-    "RUF003",
-    "RUF006",
-    "RUF012",
-    "TRY400",
-    "TRY003",
-    "TRY301"
-]
-
-[lint.per-file-ignores]
-"**/model/*.py" = ["TC003"]
-"backend/common/socketio/server.py" = ["ANN001"]
-"backend/common/exception/exception_handler.py" = ["ANN202","RUF029"]
-
-[lint.flake8-pytest-style]
-parametrize-names-type = "list"
-parametrize-values-row-type = "list"
-parametrize-values-type = "list"
-
-[lint.flake8-quotes]
-inline-quotes = "single"
-
-[lint.flake8-type-checking]
-runtime-evaluated-base-classes = ["pydantic.BaseModel", "sqlalchemy.orm.DeclarativeBase"]
-
-[lint.flake8-unused-arguments]
-ignore-variadic-names = true
-
-[lint.isort]
-case-sensitive = true
-lines-between-types = 1
-order-by-type = true
-
-[lint.pylint]
-allow-dunder-method-names = ["__tablename__", "__table_args__"]
-
-[format]
-docstring-code-format = true
-preview = true
-quote-style = "single"

.schemas/plugin.schema.json

@@ -0,0 +1,153 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "title": "FBA Plugin Manifest Schema",
+  "description": "JSON Schema for FastAPI Best Architecture plugin.toml files. See: https://fastapi-practices.github.io/fastapi_best_architecture_docs/plugin/dev.html",
+
+  "type": "object",
+  "required": ["plugin"],
+  "additionalProperties": false,
+
+  "properties": {
+    "plugin": {
+      "type": "object",
+      "description": "Plugin metadata",
+      "required": ["summary", "version", "description", "author", "tags"],
+      "additionalProperties": false,
+      "x-tombi-table-keys-order": "schema",
+      "properties": {
+        "icon": {
+          "type": "string",
+          "description": "Icon path (plugin repository icon path or URL)"
+        },
+        "summary": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 100,
+          "description": "Brief summary (1-100 characters)"
+        },
+        "version": {
+          "type": "string",
+          "pattern": "^\\d+\\.\\d+\\.\\d+$",
+          "description": "Plugin version (semver format: x.y.z)"
+        },
+        "description": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 500,
+          "description": "Detailed description (1-500 characters)"
+        },
+        "author": {
+          "type": "string",
+          "minLength": 1,
+          "maxLength": 50,
+          "description": "Plugin author (1-50 characters)"
+        },
+        "tags": {
+          "type": "array",
+          "minItems": 1,
+          "description": "Plugin tags for categorization",
+          "items": {
+            "type": "string",
+            "enum": ["ai", "mcp", "agent", "auth", "storage", "notification", "task", "payment", "other"]
+          },
+          "x-tombi-array-values-order": "ascending"
+        },
+        "database": {
+          "type": "array",
+          "minItems": 1,
+          "description": "Supported databases. Required for app-level and extend-level plugins, optional for capability-level plugins without models.",
+          "items": {
+            "type": "string",
+            "enum": ["mysql", "postgresql"]
+          },
+          "x-tombi-array-values-order": "ascending"
+        },
+        "depends_on": {
+          "type": "array",
+          "description": "List of plugin names this plugin depends on (used for startup order)",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          },
+          "x-tombi-array-values-order": "ascending"
+        }
+      }
+    },
+
+    "app": {
+      "type": "object",
+      "description": "Application configuration. For app-level plugins: use 'router'. For extend-level plugins: use 'extend'.",
+      "additionalProperties": false,
+      "minProperties": 1,
+      "x-tombi-table-keys-order": "schema",
+      "properties": {
+        "extend": {
+          "type": "string",
+          "minLength": 1,
+          "description": "Parent app folder name (for extension-level plugins)"
+        },
+        "router": {
+          "type": "array",
+          "minItems": 1,
+          "description": "Router instances (for application-level plugins)",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          },
+          "x-tombi-array-values-order": "version-sort"
+        }
+      }
+    },
+
+    "settings": {
+      "type": "object",
+      "description": "Plugin base configuration (hot-pluggable, uppercase keys only)",
+      "x-tombi-additional-key-label": "SETTING_NAME",
+      "x-tombi-table-keys-order": "ascending",
+      "propertyNames": {
+        "pattern": "^[A-Z][A-Z0-9_]*$"
+      },
+      "additionalProperties": {
+        "oneOf": [
+          { "type": "string" },
+          { "type": "number" },
+          { "type": "boolean" },
+          {
+            "type": "array",
+            "items": { "type": "string" }
+          }
+        ]
+      }
+    },
+
+    "api": {
+      "type": "object",
+      "description": "API endpoint configurations (for extension-level plugins). The key (e.g., 'xxx' in api.xxx) corresponds to the API filename without extension.",
+      "x-tombi-additional-key-label": "api_filename",
+      "x-tombi-table-keys-order": "ascending",
+      "minProperties": 1,
+      "propertyNames": {
+        "pattern": "^[a-zA-Z_][a-zA-Z0-9_]*$"
+      },
+      "additionalProperties": {
+        "type": "object",
+        "required": ["prefix", "tags"],
+        "additionalProperties": false,
+        "x-tombi-table-keys-order": {"properties": "schema"},
+        "properties": {
+          "prefix": {
+            "type": "string",
+            "minLength": 1,
+            "pattern": "^/[a-zA-Z0-9_/-]*$",
+            "description": "URL prefix for the API (must start with '/', allowed chars: a-z, A-Z, 0-9, _, -, /)"
+          },
+          "tags": {
+            "type": "string",
+            "minLength": 1,
+            "description": "OpenAPI tags for Swagger documentation"
+          }
+        }
+      }
+    }
+  }
+}

CONTRIBUTING.md

@@ -0,0 +1,60 @@
+## Backend
+
+1. Prerequisites
+
+    - Python >= 3.10
+    - Git
+    - [uv](https://docs.astral.sh/uv/getting-started/installation/)
+    - Fork this repository to your GitHub account
+
+2. Installation and setup
+
+   Clone your forked repository:
+
+   ```shell
+   git clone https://github.com/<your account>/fastapi_best_architecture.git
+   ```
+
+   Go to the root directory of the project, open the terminal, and run the following command:
+
+   ```sh
+   uv run fba init --auto
+   ```
+
+3. Checkout
+
+   Checkout a new branch and make your changes
+
+   ```shell
+   git checkout -b your-new-feature-branch
+   ```
+
+4. Format and Lint
+
+   ```shell
+   fba format
+   ```
+
+5. Commit and push
+
+   Commit your changes and push your branch to the GitHub.
+
+6. PR
+
+   Create a PR via GitHub
+
+## Scripts
+
+> [!WARNING]
+>
+> The following script may not apply to the Windows platform
+>
+> It is recommended to execute under the backend directory, and chmod authorization may be required
+
+- `migrate.sh`: Perform automatic database migration
+
+- `scripts/format.sh`: Perform ruff format with preview
+
+- `scripts/lint.sh`: Perform prek formatting
+
+- `scripts/export.sh`: Execute uv export dependency package

Dockerfile

@@ -1,68 +1,41 @@
-# Select the image to build based on SERVER_TYPE, defaulting to fba_server, or docker-compose build args
+# Python environment from uv
-ARG SERVER_TYPE=fba_server
+FROM ghcr.io/astral-sh/uv:python3.10-trixie-slim AS builder
 
-# === Python environment from uv ===
-FROM ghcr.io/astral-sh/uv:python3.10-bookworm-slim AS builder
-
-# Used for build Python packages
 RUN sed -i 's/deb.debian.org/mirrors.ustc.edu.cn/g' /etc/apt/sources.list.d/debian.sources \
     && apt-get update \
-    && apt-get install -y --no-install-recommends gcc python3-dev \
+    && apt-get install -y --no-install-recommends gcc make python3-dev \
     && rm -rf /var/lib/apt/lists/*
 
 COPY . /fba
-
 WORKDIR /fba
 
-# Configure uv environment
 ENV UV_COMPILE_BYTECODE=1 \
     UV_NO_CACHE=1 \
     UV_LINK_MODE=copy \
     UV_PROJECT_ENVIRONMENT=/usr/local
 
-# Install dependencies with cache
 RUN --mount=type=cache,target=/root/.cache/uv \
-    uv sync --frozen --no-default-groups --group server
+    --mount=type=bind,source=uv.lock,target=uv.lock \
+    --mount=type=bind,source=pyproject.toml,target=pyproject.toml \
+    uv sync --locked --no-default-groups --group server --no-install-project
 
-# === Runtime base server image ===
+# Preinstall plugin dependencies
-FROM python:3.10-slim AS base_server
+RUN --mount=type=cache,target=/root/.cache/uv \
+    python -c "from backend.plugin.requirements import install_requirements; install_requirements(None)"
+
+# Single FastAPI server image
+FROM ghcr.io/astral-sh/uv:python3.10-trixie-slim
 
 RUN sed -i 's/deb.debian.org/mirrors.ustc.edu.cn/g' /etc/apt/sources.list.d/debian.sources \
     && apt-get update \
-    && apt-get install -y --no-install-recommends supervisor \
+    && apt-get install -y --no-install-recommends curl ca-certificates supervisor \
     && rm -rf /var/lib/apt/lists/*
 
 COPY --from=builder /fba /fba
-
 COPY --from=builder /usr/local /usr/local
-
+COPY deploy/backend/supervisor/supervisord.conf /etc/supervisor/supervisord.conf
-COPY deploy/backend/supervisord.conf /etc/supervisor/supervisord.conf
+COPY deploy/backend/supervisor/fba_server.conf /etc/supervisor/conf.d/
-
-WORKDIR /fba/backend
-
-# === FastAPI server image ===
-FROM base_server AS fba_server
-
-COPY deploy/backend/fba_server.conf /etc/supervisor/conf.d/
 
 RUN mkdir -p /var/log/fba
-
 EXPOSE 8001
-
+CMD ["supervisord", "-c", "/etc/supervisor/supervisord.conf"]
-CMD ["/usr/local/bin/granian", "main:app", "--interface", "asgi", "--host", "0.0.0.0", "--port","8000"]
-
-# === Celery server image ===
-FROM base_server AS fba_celery
-
-COPY deploy/backend/fba_celery.conf /etc/supervisor/conf.d/
-
-RUN mkdir -p /var/log/fba
-
-RUN chmod +x celery-start.sh
-
-EXPOSE 8555
-
-CMD ["./celery-start.sh"]
-
-# Build image
-FROM ${SERVER_TYPE}

README.md

@@ -1,78 +1,7 @@
-<div align="center">
+# FastAPI Best Architecture Slim
 
-<img alt="The logo includes the abstract combination of the three letters FBA, forming a lightning bolt that seems to spread out from the ground" width="320" src="https://wu-clan.github.io/picx-images-hosting/logo/fba.png">
+专注于基本架构的 API 开发简化版本
 
-# FastAPI Best Architecture
+完整版请查看 [FastAPI Best Architecture](https://github.com/fastapi-practices/fastapi-best-architecture)
 
-Enterprise-level backend architecture solution
+简体中文 | [English](./README.zh-CN.md)
-
-English | [简体中文](./README.zh-CN.md)
-
-[![GitHub](https://img.shields.io/github/license/fastapi-practices/fastapi_best_architecture)](https://github.com/fastapi-practices/fastapi_best_architecture/blob/master/LICENSE)
-[![Python](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/downloads/)
-![MySQL](https://img.shields.io/badge/MySQL-8.0%2B-%2300758f)
-![PostgreSQL](https://img.shields.io/badge/PostgreSQL-16.0%2B-%23336791)
-![SQLAlchemy](https://img.shields.io/badge/SQLAlchemy-2.0-%23778877)
-[![Pydantic v2](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/pydantic/pydantic/main/docs/badge/v2.json)](https://pydantic.dev)
-[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
-[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
-![Docker](https://img.shields.io/badge/Docker-%232496ED?logo=docker&logoColor=white)
-[![Discord](https://img.shields.io/badge/Discord-%235865F2.svg?logo=discord&logoColor=white)](https://discord.com/invite/yNN3wTbVAC)
-![Discord](https://img.shields.io/discord/1185035164577972344)
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/fastapi-practices/fastapi_best_architecture)
-
-</div>
-
-## Pseudo 3-tier architecture
-
-The mvc architecture is a common design pattern in python web, but the 3-tier architecture is even more fascinating
-
-In python web development, there is no common standard for the concept of 3-tier architecture, so we'll call it a
-pseudo 3-tier architecture here
-
-But please note that we don't have a traditional multi-app structure (django, springBoot...) If you don't like this
-pattern, use templates to transform it to your heart's content!
-
-| workflow       | java           | fastapi_best_architecture |
-|----------------|----------------|---------------------------|
-| view           | controller     | api                       |
-| data transmit  | dto            | schema                    |
-| business logic | service + impl | service                   |
-| data access    | dao / mapper   | crud                      |
-| model          | model / entity | model                     |
-
-## Help
-
-For more details, please check
-the [official documentation](https://fastapi-practices.github.io/fastapi_best_architecture_docs/)
-
-## Contributors
-
-<a href="https://github.com/fastapi-practices/fastapi_best_architecture/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=fastapi-practices/fastapi_best_architecture"/>
-</a>
-
-## Special thanks
-
-- [FastAPI](https://fastapi.tiangolo.com/)
-- [Pydantic](https://docs.pydantic.dev/latest/)
-- [SQLAlchemy](https://docs.sqlalchemy.org/en/20/)
-- [Casbin](https://casbin.org/zh/)
-- [Ruff](https://beta.ruff.rs/docs/)
-- ...
-
-## Interactivity
-
-[Discord](https://wu-clan.github.io/homepage/)
-
-## Sponsor us
-
-If this program has helped you, you can sponsor us with some coffee
-beans: [:coffee: Sponsor :coffee:](https://wu-clan.github.io/sponsor/)
-
-## License
-
-This project is licensed by the terms of
-the [MIT](https://github.com/fastapi-practices/fastapi_best_architecture/blob/master/LICENSE) license
-
-[![Stargazers over time](https://starchart.cc/fastapi-practices/fastapi_best_architecture.svg?variant=adaptive)](https://starchart.cc/fastapi-practices/fastapi_best_architecture)

README.zh-CN.md

@@ -1,73 +1,7 @@
-<div align="center">
+# FastAPI Best Architecture Slim
 
-<img alt="Logo 包含了 FBA 三个字母抽象结合，形成了一个类似从地面扩散投影上来的闪电" width="320" src="https://wu-clan.github.io/picx-images-hosting/logo/fba.png">
+A simplified version focused on basic architecture for API development
 
-# FastAPI Best Architecture
+See the [full FastAPI Best Architecture project](https://github.com/fastapi-practices/fastapi-best-architecture)
 
-企业级后端架构解决方案
+English | [简体中文](./README.md)
-
-简体中文 | [English](./README.md)
-
-[![GitHub](https://img.shields.io/github/license/fastapi-practices/fastapi_best_architecture)](https://github.com/fastapi-practices/fastapi_best_architecture/blob/master/LICENSE)
-[![Python](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/downloads/)
-![MySQL](https://img.shields.io/badge/MySQL-8.0%2B-%2300758f)
-![PostgreSQL](https://img.shields.io/badge/PostgreSQL-16.0%2B-%23336791)
-![SQLAlchemy](https://img.shields.io/badge/SQLAlchemy-2.0-%23778877)
-[![Pydantic v2](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/pydantic/pydantic/main/docs/badge/v2.json)](https://pydantic.dev)
-[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
-[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
-![Docker](https://img.shields.io/badge/Docker-%232496ED?logo=docker&logoColor=white)
-[![Discord](https://img.shields.io/badge/Discord-%235865F2.svg?logo=discord&logoColor=white)](https://discord.com/invite/yNN3wTbVAC)
-![Discord](https://img.shields.io/discord/1185035164577972344)
-[![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/fastapi-practices/fastapi_best_architecture)
-
-</div>
-
-## 伪三层架构
-
-mvc 架构作为常规设计模式，在 python web 中也很常见，但是三层架构更令人着迷
-
-在 python web 开发中，三层架构的概念并没有通用标准，所以这里我们称之为伪三层架构
-
-但请注意，我们并没有传统的多应用程序结构（django、springBoot...），如果您不喜欢这种模式，可以使用模板对其进行随意改造！
-
-| 工作流程 | java           | fastapi_best_architecture |
-|------|----------------|---------------------------|
-| 视图   | controller     | api                       |
-| 数据传输 | dto            | schema                    |
-| 业务逻辑 | service + impl | service                   |
-| 数据访问 | dao / mapper   | crud                      |
-| 模型   | model / entity | model                     |
-
-## 帮助
-
-更多详情请查看 [官方文档](https://fastapi-practices.github.io/fastapi_best_architecture_docs/)
-
-## 贡献者
-
-<a href="https://github.com/fastapi-practices/fastapi_best_architecture/graphs/contributors">
-  <img src="https://contrib.rocks/image?repo=fastapi-practices/fastapi_best_architecture"/>
-</a>
-
-## 特别鸣谢
-
-- [FastAPI](https://fastapi.tiangolo.com/)
-- [Pydantic](https://docs.pydantic.dev/latest/)
-- [SQLAlchemy](https://docs.sqlalchemy.org/en/20/)
-- [Casbin](https://casbin.org/zh/)
-- [Ruff](https://beta.ruff.rs/docs/)
-- ...
-
-## 互动
-
-[Discord](https://wu-clan.github.io/homepage/)
-
-## 赞助我们
-
-如果此项目能够帮助到你，你可以赞助作者一些咖啡豆表示鼓励：[:coffee: Sponsor :coffee:](https://wu-clan.github.io/sponsor/)
-
-## 许可证
-
-本项目由 [MIT](https://github.com/fastapi-practices/fastapi_best_architecture/blob/master/LICENSE) 许可证的条款进行许可
-
-[![Stargazers over time](https://starchart.cc/fastapi-practices/fastapi_best_architecture.svg?variant=adaptive)](https://starchart.cc/fastapi-practices/fastapi_best_architecture)

SLIM_GUIDE.md

@@ -0,0 +1,304 @@
+# FBA-Slim 瘦身指南
+
+> 本文档记录了 fba-slim 与 fba 完整版之间的差异，方便日后从完整版合并代码时快速瘦身
+
+## 功能差异概览
+
+| 模块                            | 完整版 | 精简版 | 说明                          |
+|-------------------------------|-----|-----|-----------------------------|
+| 用户认证 (JWT)                    | ✅   | ✅   | 完整保留                        |
+| RBAC (角色/菜单/部门/权限校验)          | ✅   | ❌   | 整体移除，仅保留 `DependsSuperUser` |
+| 用户 CRUD                       | ✅   | ✅   | 保留（移除 dept/role 关联）         |
+| 操作日志/登录日志                     | ✅   | ❌   | 移除 DB 日志，中间件仅控制台输出          |
+| 多级缓存 (Local + Redis + PubSub) | ✅   | ✅   | 完整保留                        |
+| Snowflake 分布式 ID              | ✅   | ✅   | 完整保留                        |
+| 文件上传                          | ✅   | ✅   | 完整保留                        |
+| 密码安全/历史记录                     | ✅   | ✅   | 完整保留                        |
+| config 插件                     | ✅   | ✅   | 保留                          |
+| 插件核心系统                        | ✅   | ✅   | 保留插件安装/卸载机制，内置仅 `config` |
+| Celery 任务系统                   | ✅   | ❌   | 整体移除                        |
+| Socket.IO 实时通信                | ✅   | ❌   | 整体移除                        |
+| Prometheus + OTel 可观测性        | ✅   | ❌   | 整体移除                        |
+| 监控 API (online/redis/server)  | ✅   | ❌   | 整体移除                        |
+| 数据权限 (DataRule/DataScope)     | ✅   | ❌   | 整体移除                        |
+| dict 插件                       | ✅   | ❌   | 整体移除                        |
+| email 插件                      | ✅   | ❌   | 整体移除                        |
+| notice 插件                     | ✅   | ❌   | 整体移除                        |
+| oauth2 插件                     | ✅   | ❌   | 整体移除                        |
+| code_generator 插件             | ✅   | ❌   | 整体移除                        |
+
+## 插件范围
+
+精简版仓库只内置 `config` 插件，`backend/plugin/` 下不得保留其他业务插件目录
+
+- `backend/core/conf.py` 中 `PLUGIN_REQUIRED` 固定为 `['config']`
+- `backend/plugin/config/` 是唯一随仓库发布的插件
+- 插件核心、CLI 和插件管理 API 仍然保留，用于后续按需安装外部插件
+- 不保留 AI、dict、email、notice、oauth2、code_generator 等插件及其依赖
+
+---
+
+## 已删除的目录
+
+```
+backend/app/task/                           # Celery 任务系统
+backend/common/socketio/                    # Socket.IO 实时通信
+backend/common/observability/               # Prometheus + OpenTelemetry
+backend/app/admin/api/v1/monitor/           # 监控 API (online/redis/server)
+backend/app/admin/tests/                    # 测试文件
+backend/app/admin/api/v1/log/               # 日志 API (login_log/opera_log)
+backend/plugin/dict/                        # 字典插件
+backend/plugin/email/                       # 邮件插件
+backend/plugin/notice/                      # 通知插件
+backend/plugin/oauth2/                      # OAuth2 插件
+backend/plugin/code_generator/              # 代码生成插件
+backend/plugin/ai/                          # AI 插件
+deploy/backend/grafana/                     # Grafana 部署配置
+```
+
+## 已删除的文件
+
+```
+# RBAC (角色/菜单/部门)
+backend/app/admin/model/role.py
+backend/app/admin/model/menu.py
+backend/app/admin/model/dept.py
+backend/app/admin/model/m2m.py
+backend/app/admin/schema/role.py
+backend/app/admin/schema/menu.py
+backend/app/admin/schema/dept.py
+backend/app/admin/crud/crud_role.py
+backend/app/admin/crud/crud_menu.py
+backend/app/admin/crud/crud_dept.py
+backend/app/admin/service/role_service.py
+backend/app/admin/service/menu_service.py
+backend/app/admin/service/dept_service.py
+backend/app/admin/api/v1/sys/role.py
+backend/app/admin/api/v1/sys/menu.py
+backend/app/admin/api/v1/sys/dept.py
+backend/common/security/rbac.py
+backend/common/security/permission.py
+backend/utils/build_tree.py
+
+# 数据权限
+backend/app/admin/model/data_rule.py
+backend/app/admin/model/data_scope.py
+backend/app/admin/schema/data_rule.py
+backend/app/admin/schema/data_scope.py
+backend/app/admin/crud/crud_data_rule.py
+backend/app/admin/crud/crud_data_scope.py
+backend/app/admin/service/data_rule_service.py
+backend/app/admin/service/data_scope_service.py
+backend/app/admin/api/v1/sys/data_rule.py
+backend/app/admin/api/v1/sys/data_scope.py
+
+# 监控 API
+backend/app/admin/schema/monitor.py
+
+# 可观测性
+backend/common/observability/otel.py
+backend/common/observability/prometheus/fastapi.py
+backend/common/observability/prometheus/queue.py
+backend/common/observability/prometheus/sqlalchemy.py
+
+# 日志系统
+backend/app/admin/model/login_log.py
+backend/app/admin/model/opera_log.py
+backend/app/admin/schema/login_log.py
+backend/app/admin/schema/opera_log.py
+backend/app/admin/crud/crud_login_log.py
+backend/app/admin/crud/crud_opera_log.py
+backend/app/admin/service/login_log_service.py
+backend/app/admin/service/opera_log_service.py
+backend/common/queue.py
+
+# 部署
+deploy/backend/supervisor/fba_celery_beat.conf
+deploy/backend/supervisor/fba_celery_flower.conf
+deploy/backend/supervisor/fba_celery_worker.conf
+deploy/backend/grafana/dashboards/fba_celery.json
+```
+
+---
+
+## 已修改的文件
+
+### 模型层
+
+| 文件                                    | 修改内容                                |
+|---------------------------------------|-------------------------------------|
+| `backend/app/admin/model/__init__.py` | 仅保留 `User`、`UserPasswordHistory` 导出 |
+| `backend/app/admin/model/user.py`     | 删除 `dept_id` 字段                     |
+
+### Schema 层
+
+| 文件                                 | 修改内容                                                                                                                                     |
+|------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------|
+| `backend/app/admin/schema/user.py` | 删除 `dept_id`/`roles` 字段、`AddUserRoleParam`/`GetUserInfoWithRelationDetail`/`GetCurrentUserInfoWithRelationDetail`/`AddOAuth2UserParam` 类 |
+
+### CRUD 层
+
+| 文件                                    | 修改内容                                                                                                            |
+|---------------------------------------|-----------------------------------------------------------------------------------------------------------------|
+| `backend/app/admin/crud/crud_user.py` | 删除 Role/Dept/Menu/m2m 全部引用，移除 `get_join()` 方法、JoinConfig、m2m 操作；`add()`/`update()`/`delete()`/`get_select()` 简化 |
+
+### Service 层
+
+| 文件                                          | 修改内容                                                                              |
+|---------------------------------------------|-----------------------------------------------------------------------------------|
+| `backend/app/admin/service/user_service.py` | 删除 `get_roles()` 方法、dept/role 验证逻辑、`dept` 参数；`get_userinfo()` 改用 `user_dao.get()`/`get_by_username()`；`update_email()` 删除邮箱验证码（email 插件已移除），保留邮箱唯一性校验 |
+| `backend/app/admin/service/auth_service.py` | 删除 `login_log_service`/`menu_dao` 引用、`get_codes()` 方法、`background_tasks` 参数       |
+
+### Utils/安全层
+
+| 文件                                 | 修改内容                                                                                                 |
+|------------------------------------|------------------------------------------------------------------------------------------------------|
+| `backend/app/admin/utils/cache.py` | 删除 `clear_by_role_id()`/`clear_by_menu_id()`/`clear_by_data_scope_id()`/`clear_by_data_rule_id()` 方法 |
+| `backend/utils/trace_id.py`        | 删除 `OtelTraceIdPlugin` 类                                                                             |
+| `backend/utils/dynamic_config.py`  | 保留上游懒加载 config 插件实现，删除邮箱插件相关 `load_email_config()`，仅保留用户安全与登录配置加载                       |
+
+### API 层
+
+| 文件                                           | 修改内容                                                                                            |
+|----------------------------------------------|-------------------------------------------------------------------------------------------------|
+| `backend/app/admin/api/v1/sys/user.py`       | 删除 `get_user_roles` 路由、`dept` 参数、`update_user_email` 的 captcha 参数；`delete_user` 改用 `DependsSuperUser`；响应类型改为 `GetUserInfoDetail` |
+| `backend/app/admin/api/v1/sys/file.py`       | `RequestPermission + DependsRBAC` 改为 `DependsJwtAuth`                                           |
+| `backend/app/admin/api/v1/sys/__init__.py`   | 仅保留 `user_router`、`file_router`、`plugin_router`                                                 |
+| `backend/app/admin/api/v1/auth/auth.py`      | 删除 `get_codes` 路由、`background_tasks` 参数                                                         |
+| `backend/app/admin/api/router.py`            | 删除 `monitor_router`、`log_router`                                                                |
+| `backend/app/router.py`                      | 删除 `task_v1`                                                                                    |
+| `backend/app/admin/api/v1/sys/plugin.py`     | `RequestPermission + DependsRBAC` 改为 `DependsSuperUser`                                         |
+| `backend/plugin/config/api/v1/sys/config.py` | `RequestPermission + DependsRBAC` 改为 `DependsSuperUser`                                         |
+
+### JWT/中间件层
+
+| 文件                                           | 修改内容                                                                                                             |
+|----------------------------------------------|------------------------------------------------------------------------------------------------------------------|
+| `backend/common/security/jwt.py`             | `GetUserInfoWithRelationDetail` → `GetUserInfoDetail`；`get_current_user()` 改用 `user_dao.get()`，删除 dept/role 状态检查；保留上游 `jwt_authentication_verify` 与 `TOKEN_REQUEST_UNDERLYING_SECURITY` |
+| `backend/middleware/jwt_auth_middleware.py`  | `GetUserInfoWithRelationDetail` → `GetUserInfoDetail`                                                            |
+| `backend/middleware/opera_log_middleware.py` | 移除 DB 队列/消费者/入库，改为纯控制台日志输出；异常码读取需包含 `__request_authentication_exception__` |
+| `backend/middleware/access_middleware.py`    | 删除 Prometheus 导入和 2 处计数器调用                                                                                       |
+
+### 核心层
+
+| 文件                          | 修改内容                                                                                                                                       |
+|-----------------------------|--------------------------------------------------------------------------------------------------------------------------------------------|
+| `backend/core/registrar.py` | 删除 socketio/prometheus/otel 导入、`register_socket_app()`、`register_metrics()`、OtelTraceIdPlugin、`create_task(OperaLogMiddleware.consumer())`；保留 lifespan `try/finally` 与上游 `dispose_database()` |
+| `backend/core/conf.py`      | 删除 CELERY/GRAFANA/DATA_PERMISSION/OAUTH2/EMAIL/WS/CODE_GENERATOR/OPERA_LOG_*/RBAC_ROLE_MENU_*/CACHE_DICT_* 配置段；保留 `DATABASE_SOURCES`、`TOKEN_REQUEST_UNDERLYING_SECURITY`；`PLUGIN_REQUIRED` 仅保留 `config` |
+| `backend/database/db.py`    | 删除 SQLAlchemy 连接池 Prometheus 指标监听                                                                                                        |
+| `backend/alembic/env.py`    | 保持上游 `get_database_url()` 命名                                                                                                                |
+| `backend/main.py`           | 保留上游插件准备流程 `_prepare_plugins()`，检查必需插件并安装缺失插件依赖                                                                                         |
+| `backend/plugin/core.py`    | `get_required_plugins()` 删除 RBAC 模式相关 `casbin_rbac` 逻辑                                                                                      |
+| `backend/plugin/hooks.py`   | 保留上游插件 setup/lifespan hooks，删除 OpenTelemetry hook                                                                                         |
+
+### CLI
+
+| 文件               | 修改内容                                                                             |
+|------------------|----------------------------------------------------------------------------------|
+| `backend/cli.py` | 删除 Celery/代码生成相关命令，保留插件安装卸载与依赖同步；`FbaCli.subcmd` 为 `Init \| Run \| Add \| Remove \| Deps \| Format \| Alembic` |
+
+### Enum
+
+| 文件                        | 修改内容                                                                                                                                            |
+|---------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------|
+| `backend/common/enums.py` | 删除 `MenuType`、`MethodType`、`BuildTreeType`、`RoleDataRuleOperatorType`、`RoleDataRuleExpressionType`、`LoginLogStatusType`、`OperaLogCipherType` 枚举；保留上游 `PluginLevelType.capability` |
+| `backend/plugin/config/enums.py` | 仅保留 `ConfigType.user_security` 与 `ConfigType.login` |
+
+### SQL 初始化数据
+
+| 文件                                                    | 修改内容                                                                              |
+|-------------------------------------------------------|-----------------------------------------------------------------------------------|
+| `backend/sql/mysql/init_test_data.sql`                | 仅保留 sys_user INSERT（删除 dept/menu/role/role_menu/user_role/data_scope/data_rule 等） |
+| `backend/sql/mysql/init_snowflake_test_data.sql`      | 同上                                                                                |
+| `backend/sql/postgresql/init_test_data.sql`           | 同上                                                                                |
+| `backend/sql/postgresql/init_snowflake_test_data.sql` | 同上                                                                                |
+| `backend/plugin/config/sql/**/init*.sql`              | 删除 `sys_menu` 初始化与 EMAIL 配置，仅保留 `sys_config` 中用户安全/登录配置                         |
+| `backend/plugin/config/sql/**/destroy*.sql`           | 删除 `sys_menu` 清理语句，仅保留 `sys_config` 清理                                            |
+
+### 配置/部署
+
+| 文件                                          | 修改内容                                                                                 |
+|---------------------------------------------|--------------------------------------------------------------------------------------|
+| `backend/.env.example`                      | 删除 Celery/RabbitMQ/OAuth2/Email 环境变量；保留 `DATABASE_SOURCES` |
+| `pyproject.toml`                            | 项目名改为 `fba-slim`；删除 celery/socketio/opentelemetry/prometheus/psutil/flower/gevent/aio-pika/jinja2/psycopg/pymysql 等依赖；保留 `dulwich`（插件 Git 安装仍依赖） |
+| `README.md` / `README.zh-CN.md`             | 使用 slim 专用说明，并指向完整版仓库 |
+| `docker-compose.yml`                        | 删除 rabbitmq/celery/grafana 全套容器                                                      |
+| `Dockerfile`                                | 简化为单一 server 镜像，删除 celery worker/beat/flower 阶段；保留插件依赖预安装步骤，用于打包随镜像发布的插件依赖 |
+| `deploy/backend/docker-compose/.env.docker` | 删除 RabbitMQ/Celery/Grafana 端口映射                                                      |
+| `deploy/backend/docker-compose/.env.server` | 删除 Celery/OAuth2/Email 环境变量                                                          |
+| `deploy/backend/nginx.conf`                 | 删除 Flower 代理配置                                                                       |
+
+---
+
+## 插件依赖处理约定
+
+- `Dockerfile` 必须保留 `# Preinstall plugin dependencies`，用于镜像构建时为随包插件安装依赖；当前随包插件仅有 `config`
+- `backend/main.py` 必须保留上游 `_prepare_plugins()`，服务启动时会检查必需插件并安装缺失插件依赖
+- 后续通过插件安装接口安装 zip/git 插件时，仍由 `backend/plugin/requirements.py` 安装该插件依赖
+
+---
+
+## 合并指南
+
+从 fba 完整版同步代码到 fba-slim 后，需要关注以下冲突区域：
+
+### 快速检测 rg 模式
+
+合并后运行以下命令，快速找出需要处理的非 slim 引用：
+
+```bash
+# 全量残留扫描：唯一可接受命中是 OperaLogMiddleware 导入（控制台日志保留）
+rg -n "celery|CELERY_|app\.task|python-socketio|socketio|prometheus|opentelemetry|psutil|flower|gevent|aio-pika|rabbitmq|GRAFANA_|OAUTH2_|EMAIL_CAPTCHA|CACHE_DICT|RBAC_ROLE_MENU|DATA_PERMISSION|RequestPermission|DependsRBAC|GetUserInfoWithRelation|GetCurrentUserInfoWithRelation|sys_menu|sys_role|sys_dept|data_scope|data_rule|login_log|opera_log|casbin_rbac|OtelTraceIdPlugin|init_plugin_otel|AddOAuth2UserParam" backend pyproject.toml Dockerfile docker-compose.yml deploy -g '!**/__pycache__/**'
+
+# 精确 DB 日志 / RBAC / 数据权限残留扫描：应无命中
+rg -n "opera_log_service|login_log_service|OPERA_LOG_|batch_dequeue|opera_log_queue|LoginLog|DataRule|DataScope|RequestPermission|DependsRBAC|GetUserInfoWithRelationDetail|CACHE_DICT_REDIS_PREFIX|EMAIL_CAPTCHA_REDIS_PREFIX" backend pyproject.toml Dockerfile docker-compose.yml deploy -g '!**/__pycache__/**'
+
+# 已移除依赖残留扫描：应无命中
+rg -n "celery|celery-aio|opentelemetry|prometheus-client|psutil|python-socketio|flower|gevent|aio-pika|psycopg|pymysql" pyproject.toml
+
+# 内置插件校验：输出必须只有 config
+find backend/plugin -mindepth 1 -maxdepth 1 -type d ! -name '__pycache__' -exec basename {} \; | sort
+test "$(find backend/plugin -mindepth 1 -maxdepth 1 -type d ! -name '__pycache__' -exec basename {} \; | sort)" = config
+```
+
+> 注：slim 版仍保留 `backend/middleware/opera_log_middleware.py` 的 `OperaLogMiddleware`，用于控制台访问日志；检测 DB 日志残留时不要把该中间件类名视为问题。
+
+### 高冲突文件
+
+以下文件在完整版更新时最容易产生冲突：
+
+1. **`backend/core/conf.py`** — 配置字段差异最大
+2. **`backend/core/registrar.py`** — 中间件和组件注册差异
+3. **`backend/cli.py`** — 删除 Celery/代码生成命令，保留插件 `Add`/`Remove`/`Deps`
+4. **`backend/main.py`** — 上游插件准备流程必须保留
+5. **`backend/common/security/jwt.py`** — `GetUserInfoDetail` vs `GetUserInfoWithRelationDetail`，`get_current_user()` 差异
+6. **`backend/app/admin/crud/crud_user.py`** — 无 get_join/JoinConfig/m2m 操作
+7. **`backend/app/admin/service/auth_service.py`** — 登录日志、menu_dao、background_tasks 差异
+8. **`backend/middleware/opera_log_middleware.py`** — 完整版有 DB 队列，slim 版仅控制台
+9. **`backend/middleware/jwt_auth_middleware.py`** — schema 类型差异
+10. **`backend/plugin/config/sql/**`** — config 插件 SQL 不能再引用已删除的 `sys_menu`
+11. **`pyproject.toml`** — 依赖列表差异
+12. **`docker-compose.yml`** — 容器编排差异
+13. **`Dockerfile`** — 构建阶段差异，需保留插件依赖预安装步骤但删除 Celery 多镜像阶段
+14. **`deploy/backend/nginx.conf`** — Flower 代理容易残留
+
+### 合并策略
+
+1. **以上游新版本为基准**，只按本文档删除标准瘦身项，不要直接用旧 slim 文件覆盖上游正常演进
+2. **需要手动合并**的文件：CRUD/Service/API 层（可能有新增功能需要保留，但需移除 RBAC/数据权限/可观测性引用）
+3. **直接接受完整版**的文件：不涉及上述移除功能的纯业务逻辑改动
+4. **合并后运行上述 `rg` 命令**清理残留引用
+5. **插件依赖安装保持上游行为**：`backend/main.py` 启动时检测并安装缺失插件依赖，Dockerfile 构建时预装随包插件依赖
+6. **运行 `fba format` 和导入检查**确认格式、锁文件、导出依赖和导入无误
+7. **插件 CLI 必须保留**：插件核心系统完整保留，因此 `fba add` / `fba remove` / `fba deps` 与插件安装 API 一并保留；不要再删除插件安装卸载命令
+
+### 验证清单
+
+瘦身完成后至少运行：
+
+```bash
+fba format
+uv run python -c "from backend.main import app; print(app.title); print(sorted(app.openapi()['paths']))"
+```
+
+> FastAPI 0.141+ 将 `include_router` 存为嵌套 `_IncludedRouter`，`len(app.routes)` 不再等于接口数量；请用 OpenAPI paths 核对。精简版应只有 auth/user/file/plugin/config，不应出现 role/menu/dept/log/monitor/task 或 AI 插件路由。

backend/.env.example

@@ -6,6 +6,9 @@ DATABASE_HOST='127.0.0.1'
 DATABASE_PORT=5432
 DATABASE_USER='postgres'
 DATABASE_PASSWORD='123456'
+# 额外数据源
+# DATABASE_SOURCES='{"read": "postgresql+asyncpg://user:password@host:5432/fba"}'
+DATABASE_SOURCES='{}'
 # Redis
 REDIS_HOST='127.0.0.1'
 REDIS_PORT=6379
@@ -13,23 +16,3 @@ REDIS_PASSWORD=''
 REDIS_DATABASE=0
 # Token
 TOKEN_SECRET_KEY='1VkVF75nsNABBjK_7-qz7GtzNy3AMvktc9TCPwKczCk'
-# Opera Log
-OPERA_LOG_ENCRYPT_SECRET_KEY='d77b25790a804c2b4a339dd0207941e4cefa5751935a33735bc73bb7071a005b'
-# [ App ] task
-# Celery
-CELERY_BROKER_REDIS_DATABASE=1
-# Rabbitmq
-CELERY_RABBITMQ_HOST='127.0.0.1'
-CELERY_RABBITMQ_PORT=5672
-CELERY_RABBITMQ_USERNAME='guest'
-CELERY_RABBITMQ_PASSWORD='guest'
-# [ Plugin ] oauth2
-OAUTH2_GITHUB_CLIENT_ID='test'
-OAUTH2_GITHUB_CLIENT_SECRET='test'
-OAUTH2_GOOGLE_CLIENT_ID='test'
-OAUTH2_GOOGLE_CLIENT_SECRET='test'
-OAUTH2_LINUX_DO_CLIENT_ID='test'
-OAUTH2_LINUX_DO_CLIENT_SECRET='test'
-# [ Plugin ] email
-EMAIL_USERNAME=''
-EMAIL_PASSWORD=''

backend/README.md

@@ -16,68 +16,3 @@
    ```shell
    docker run -d -p 8000:8000 --name fba_server fba_backend_independent
    ```
-
-## Contributing
-
-1. Prerequisites
-
-    - Python >= 3.10
-    - Git
-    - [uv](https://docs.astral.sh/uv/getting-started/installation/)
-    - Fork this repository to your GitHub account
-
-2. Installation and setup
-
-   Clone your forked repository:
-
-   ```shell
-   git clone https://github.com/<your account>/fastapi_best_architecture.git
-   ```
-
-   Go to the root directory of the project, open the terminal, and run the following command:
-
-   ```sh
-   uv sync --frozen
-   ```
-
-3. Checkout
-
-   Checkout a new branch and make your changes
-
-   ```shell
-   git checkout -b your-new-feature-branch
-   ```
-
-4. Format and Lint
-
-   Auto-formatting and lint via `prek`
-
-   ```shell
-   prek run --all-files
-   ```
-
-5. Commit and push
-
-   Commit your changes and push your branch to the GitHub.
-
-6. PR
-
-   Create a PR via GitHub
-
-## Scripts
-
-> [!WARNING]
->
-> The following script may not apply to the Windows platform
->
-> It is recommended to execute under the backend directory, and chmod authorization may be required
-
-- `pre_start.sh`: Perform automatic database migration
-
-- `celery-start.sh`: For celery docker script, implementation is not recommended
-
-- `scripts/format.sh`: Perform ruff format check
-
-- `scripts/lint.sh`: Perform prek formatting
-
-- `scripts/export.sh`: Execute uv export dependency package

backend/__init__.py

@@ -1 +1,17 @@
-__version__ = '1.11.2'
+import sqlalchemy as sa
+
+from backend.utils.dynamic_import import get_all_models
+
+
+def _register_model_globals() -> None:
+    """导入所有模型并注册到 backend 模块命名空间"""
+    for model_obj in get_all_models():
+        model_name = model_obj.name if isinstance(model_obj, sa.Table) else model_obj.__name__
+        if model_name not in globals():
+            globals()[model_name] = model_obj
+
+
+_register_model_globals()
+
+
+__version__ = '1.15.1'

backend/alembic.ini

@@ -1,84 +1,3 @@
-# A generic, single database configuration.
-
-[alembic]
-# path to migration scripts.
-# Use forward slashes (/) also on windows to provide an os agnostic path
-script_location = alembic
-
-# template used to generate migration file names; The default value is %%(rev)s_%%(slug)s
-# Uncomment the line below if you want the files to be prepended with date and time
-file_template = %%(year)d-%%(month).2d-%%(day).2d-%%(hour).2d_%%(minute).2d_%%(second).2d-%%(rev)s_%%(slug)s
-
-# sys.path path, will be prepended to sys.path if present.
-# defaults to the current working directory.
-prepend_sys_path = .
-
-# timezone to use when rendering the date within the migration file
-# as well as the filename.
-# If specified, requires the python>=3.9 or backports.zoneinfo library.
-# Any required deps can installed by adding `alembic[tz]` to the pip requirements
-# string value is passed to ZoneInfo()
-# leave blank for localtime
-# timezone =
-
-# max length of characters to apply to the "slug" field
-# truncate_slug_length = 40
-
-# set to 'true' to run the environment during
-# the 'revision' command, regardless of autogenerate
-# revision_environment = false
-
-# set to 'true' to allow .pyc and .pyo files without
-# a source .py file to be detected as revisions in the
-# versions/ directory
-# sourceless = false
-
-# version location specification; This defaults
-# to alembic/versions.  When using multiple version
-# directories, initial revisions must be specified with --version-path.
-# The path separator used here should be the separator specified by "version_path_separator" below.
-# version_locations = %(here)s/bar:%(here)s/bat:alembic/versions
-
-# version path separator; As mentioned above, this is the character used to split
-# version_locations. The default within new alembic.ini files is "os", which uses os.pathsep.
-# If this key is omitted entirely, it falls back to the legacy behavior of splitting on spaces and/or commas.
-# Valid values for version_path_separator are:
-#
-# version_path_separator = :
-# version_path_separator = ;
-# version_path_separator = space
-# version_path_separator = newline
-version_path_separator = os  # Use os.pathsep. Default configuration used for new projects.
-
-# set to 'true' to search source files recursively
-# in each "version_locations" directory
-# new in Alembic version 1.10
-# recursive_version_locations = false
-
-# the output encoding used when revision files
-# are written from script.py.mako
-# output_encoding = utf-8
-
-sqlalchemy.url = driver://user:pass@localhost/dbname
-
-
-[post_write_hooks]
-# post_write_hooks defines scripts or Python functions that are run
-# on newly generated revision scripts.  See the documentation for further
-# detail and examples
-
-# format using "black" - use the console_scripts runner, against the "black" entrypoint
-# hooks = black
-# black.type = console_scripts
-# black.entrypoint = black
-# black.options = -l 79 REVISION_SCRIPT_FILENAME
-
-# lint with attempts to fix using "ruff" - use the exec runner, execute a binary
-# hooks = ruff
-# ruff.type = exec
-# ruff.executable = %(here)s/.venv/bin/ruff
-# ruff.options = --fix REVISION_SCRIPT_FILENAME
-
 # Logging configuration
 [loggers]
 keys = root,sqlalchemy,alembic

backend/alembic/env.py

@@ -8,38 +8,34 @@ from sqlalchemy import pool
 from sqlalchemy.engine import Connection
 from sqlalchemy.ext.asyncio import async_engine_from_config
 
-from backend.app import get_app_models
 from backend.common.model import MappedBase
 from backend.core import path_conf
-from backend.database.db import SQLALCHEMY_DATABASE_URL
+from backend.core.path_conf import BASE_PATH
-from backend.plugin.tools import get_plugin_models
+from backend.database.db import get_database_url
-
-# import models
-for cls in get_app_models() + get_plugin_models():
-    class_name = cls.__name__
-    if class_name not in globals():
-        globals()[class_name] = cls
 
 if not os.path.exists(path_conf.ALEMBIC_VERSION_DIR):
     os.makedirs(path_conf.ALEMBIC_VERSION_DIR)
 
 # this is the Alembic Config object, which provides
 # access to the values within the .ini file in use.
-alembic_config = context.config
+config = context.config
 
 # Interpret the config file for Python logging.
 # This line sets up loggers basically.
-if alembic_config.config_file_name is not None:
+if config.config_file_name is not None:
-    fileConfig(alembic_config.config_file_name)
+    fileConfig(BASE_PATH / config.config_file_name)
 
-# model's MetaData object
+# add your model's MetaData object here
 # for 'autogenerate' support
 target_metadata = MappedBase.metadata
 
 # other values from the config, defined by the needs of env.py,
-alembic_config.set_main_option(
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+config.set_main_option(
     'sqlalchemy.url',
-    SQLALCHEMY_DATABASE_URL.render_as_string(hide_password=False).replace('%', '%%'),
+    get_database_url().render_as_string(hide_password=False).replace('%', '%%'),
 )
 
 
@@ -55,7 +51,7 @@ def run_migrations_offline() -> None:
     script output.
 
     """
-    url = alembic_config.get_main_option('sqlalchemy.url')
+    url = config.get_main_option('sqlalchemy.url')
     context.configure(
         url=url,
         target_metadata=target_metadata,
@@ -71,9 +67,9 @@ def run_migrations_offline() -> None:
 
 
 def do_run_migrations(connection: Connection) -> None:
-    # 当迁移无变化时，不生成迁移记录
+    def process_revision_directives(context, revision, directives) -> None:  # ruff:ignore[missing-type-function-argument]
-    def process_revision_directives(context, revision, directives) -> None:  # noqa: ANN001
+        """当迁移无变化时，不生成迁移记录"""
-        if alembic_config.cmd_opts.autogenerate:
+        if config.cmd_opts.autogenerate:
             script = directives[0]
             if script.upgrade_ops.is_empty():
                 directives[:] = []
@@ -99,7 +95,7 @@ async def run_async_migrations() -> None:
     """
 
     connectable = async_engine_from_config(
-        alembic_config.get_section(alembic_config.config_ini_section, {}),
+        config.get_section(config.config_ini_section, {}),
         prefix='sqlalchemy.',
         poolclass=pool.NullPool,
     )

backend/app/__init__.py

@@ -1,28 +0,0 @@
-import os.path
-
-from backend.core.path_conf import BASE_PATH
-from backend.utils.import_parse import get_model_objects
-
-
-def get_app_models() -> list[type]:
-    """获取 app 所有模型类"""
-    app_path = BASE_PATH / 'app'
-    list_dirs = os.listdir(app_path)
-
-    apps = [d for d in list_dirs if os.path.isdir(os.path.join(app_path, d)) and d != '__pycache__']
-
-    objs = []
-    for app in apps:
-        module_path = f'backend.app.{app}.model'
-        obj = get_model_objects(module_path)
-        if obj:
-            objs.extend(obj)
-
-    return objs
-
-
-# import all app models for auto create db tables
-for cls in get_app_models():
-    class_name = cls.__name__
-    if class_name not in globals():
-        globals()[class_name] = cls

backend/app/admin/api/router.py

@@ -1,8 +1,6 @@
 from fastapi import APIRouter
 
 from backend.app.admin.api.v1.auth import router as auth_router
-from backend.app.admin.api.v1.log import router as log_router
-from backend.app.admin.api.v1.monitor import router as monitor_router
 from backend.app.admin.api.v1.sys import router as sys_router
 from backend.core.conf import settings
 
@@ -10,5 +8,3 @@ v1 = APIRouter(prefix=settings.FASTAPI_API_V1_PATH)
 
 v1.include_router(auth_router)
 v1.include_router(sys_router)
-v1.include_router(log_router)
-v1.include_router(monitor_router)

backend/app/admin/api/v1/auth/auth.py

@@ -2,15 +2,14 @@ from typing import Annotated
 
 from fastapi import APIRouter, Depends, Request, Response
 from fastapi.security import HTTPBasicCredentials
-from fastapi_limiter.depends import RateLimiter
+from pyrate_limiter import Duration, Rate
-from starlette.background import BackgroundTasks
 
 from backend.app.admin.schema.token import GetLoginToken, GetNewToken, GetSwaggerToken
 from backend.app.admin.schema.user import AuthLoginParam
 from backend.app.admin.service.auth_service import auth_service
 from backend.common.response.response_schema import ResponseModel, ResponseSchemaModel, response_base
-from backend.common.security.jwt import DependsJwtAuth
 from backend.database.db import CurrentSession, CurrentSessionTransaction
+from backend.utils.limiter import RateLimiter
 
 router = APIRouter()
 
@@ -27,27 +26,20 @@ async def login_swagger(
     '/login',
     summary='用户登录',
     description='json 格式登录, 仅支持在第三方api工具调试, 例如: postman',
-    dependencies=[Depends(RateLimiter(times=5, minutes=1))],
+    dependencies=[Depends(RateLimiter(Rate(5, Duration.MINUTE)))],
 )
 async def login(
     db: CurrentSessionTransaction,
     response: Response,
     obj: AuthLoginParam,
-    background_tasks: BackgroundTasks,
 ) -> ResponseSchemaModel[GetLoginToken]:
-    data = await auth_service.login(db=db, response=response, obj=obj, background_tasks=background_tasks)
+    data = await auth_service.login(db=db, response=response, obj=obj)
     return response_base.success(data=data)
 
 
-@router.get('/codes', summary='获取所有授权码', description='适配 vben admin v5', dependencies=[DependsJwtAuth])
-async def get_codes(db: CurrentSession, request: Request) -> ResponseSchemaModel[list[str]]:
-    codes = await auth_service.get_codes(db=db, request=request)
-    return response_base.success(data=codes)
-
-
 @router.post('/refresh', summary='刷新 token')
-async def refresh_token(db: CurrentSession, request: Request) -> ResponseSchemaModel[GetNewToken]:
+async def refresh_token(db: CurrentSession, request: Request, response: Response) -> ResponseSchemaModel[GetNewToken]:
-    data = await auth_service.refresh_token(db=db, request=request)
+    data = await auth_service.refresh_token(db=db, request=request, response=response)
     return response_base.success(data=data)
 
 

backend/app/admin/api/v1/auth/captcha.py

@@ -2,7 +2,7 @@ import uuid
 
 from fast_captcha import img_captcha
 from fastapi import APIRouter, Depends
-from fastapi_limiter.depends import RateLimiter
+from pyrate_limiter import Duration, Rate
 from starlette.concurrency import run_in_threadpool
 
 from backend.app.admin.schema.captcha import GetCaptchaDetail
@@ -11,6 +11,7 @@ from backend.core.conf import settings
 from backend.database.db import CurrentSession
 from backend.database.redis import redis_client
 from backend.utils.dynamic_config import load_login_config
+from backend.utils.limiter import RateLimiter
 
 router = APIRouter()
 
@@ -18,7 +19,7 @@ router = APIRouter()
 @router.get(
     '/captcha',
     summary='获取登录验证码',
-    dependencies=[Depends(RateLimiter(times=5, seconds=10))],
+    dependencies=[Depends(RateLimiter(Rate(5, Duration.SECOND * 30)))],
 )
 async def get_captcha(db: CurrentSession) -> ResponseSchemaModel[GetCaptchaDetail]:
     await load_login_config(db)

backend/app/admin/api/v1/log/__init__.py

@@ -1,9 +0,0 @@
-from fastapi import APIRouter
-
-from backend.app.admin.api.v1.log.login_log import router as login_log
-from backend.app.admin.api.v1.log.opera_log import router as opera_log
-
-router = APIRouter(prefix='/logs')
-
-router.include_router(login_log, prefix='/login', tags=['登录日志'])
-router.include_router(opera_log, prefix='/opera', tags=['操作日志'])

backend/app/admin/api/v1/log/login_log.py

@@ -1,61 +0,0 @@
-from typing import Annotated
-
-from fastapi import APIRouter, Depends, Query
-
-from backend.app.admin.schema.login_log import DeleteLoginLogParam, GetLoginLogDetail
-from backend.app.admin.service.login_log_service import login_log_service
-from backend.common.pagination import DependsPagination, PageData
-from backend.common.response.response_schema import ResponseModel, ResponseSchemaModel, response_base
-from backend.common.security.jwt import DependsJwtAuth
-from backend.common.security.permission import RequestPermission
-from backend.common.security.rbac import DependsRBAC
-from backend.database.db import CurrentSession, CurrentSessionTransaction
-
-router = APIRouter()
-
-
-@router.get(
-    '',
-    summary='分页获取登录日志',
-    dependencies=[
-        DependsJwtAuth,
-        DependsPagination,
-    ],
-)
-async def get_login_logs_paginated(
-    db: CurrentSession,
-    username: Annotated[str | None, Query(description='用户名')] = None,
-    status: Annotated[int | None, Query(description='状态')] = None,
-    ip: Annotated[str | None, Query(description='IP 地址')] = None,
-) -> ResponseSchemaModel[PageData[GetLoginLogDetail]]:
-    page_data = await login_log_service.get_list(db=db, username=username, status=status, ip=ip)
-
-    return response_base.success(data=page_data)
-
-
-@router.delete(
-    '',
-    summary='批量删除登录日志',
-    dependencies=[
-        Depends(RequestPermission('log:login:del')),
-        DependsRBAC,
-    ],
-)
-async def delete_login_logs(db: CurrentSessionTransaction, obj: DeleteLoginLogParam) -> ResponseModel:
-    count = await login_log_service.delete(db=db, obj=obj)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()
-
-
-@router.delete(
-    '/all',
-    summary='清空登录日志',
-    dependencies=[
-        Depends(RequestPermission('log:login:clear')),
-        DependsRBAC,
-    ],
-)
-async def delete_all_login_logs(db: CurrentSessionTransaction) -> ResponseModel:
-    await login_log_service.delete_all(db=db)
-    return response_base.success()

backend/app/admin/api/v1/log/opera_log.py

@@ -1,61 +0,0 @@
-from typing import Annotated
-
-from fastapi import APIRouter, Depends, Query
-
-from backend.app.admin.schema.opera_log import DeleteOperaLogParam, GetOperaLogDetail
-from backend.app.admin.service.opera_log_service import opera_log_service
-from backend.common.pagination import DependsPagination, PageData
-from backend.common.response.response_schema import ResponseModel, ResponseSchemaModel, response_base
-from backend.common.security.jwt import DependsJwtAuth
-from backend.common.security.permission import RequestPermission
-from backend.common.security.rbac import DependsRBAC
-from backend.database.db import CurrentSession, CurrentSessionTransaction
-
-router = APIRouter()
-
-
-@router.get(
-    '',
-    summary='分页获取操作日志',
-    dependencies=[
-        DependsJwtAuth,
-        DependsPagination,
-    ],
-)
-async def get_opera_logs_paginated(
-    db: CurrentSession,
-    username: Annotated[str | None, Query(description='用户名')] = None,
-    status: Annotated[int | None, Query(description='状态')] = None,
-    ip: Annotated[str | None, Query(description='IP 地址')] = None,
-) -> ResponseSchemaModel[PageData[GetOperaLogDetail]]:
-    page_data = await opera_log_service.get_list(db=db, username=username, status=status, ip=ip)
-
-    return response_base.success(data=page_data)
-
-
-@router.delete(
-    '',
-    summary='批量删除操作日志',
-    dependencies=[
-        Depends(RequestPermission('log:opera:del')),
-        DependsRBAC,
-    ],
-)
-async def delete_opera_logs(db: CurrentSessionTransaction, obj: DeleteOperaLogParam) -> ResponseModel:
-    count = await opera_log_service.delete(db=db, obj=obj)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()
-
-
-@router.delete(
-    '/all',
-    summary='清空操作日志',
-    dependencies=[
-        Depends(RequestPermission('log:opera:clear')),
-        DependsRBAC,
-    ],
-)
-async def delete_all_opera_logs(db: CurrentSessionTransaction) -> ResponseModel:
-    await opera_log_service.delete_all(db=db)
-    return response_base.success()

backend/app/admin/api/v1/monitor/__init__.py

@@ -1,11 +0,0 @@
-from fastapi import APIRouter
-
-from backend.app.admin.api.v1.monitor.online import router as token_router
-from backend.app.admin.api.v1.monitor.redis import router as redis_router
-from backend.app.admin.api.v1.monitor.server import router as server_router
-
-router = APIRouter(prefix='/monitors')
-
-router.include_router(redis_router, prefix='/redis', tags=['redis监控'])
-router.include_router(server_router, prefix='/server', tags=['服务器监控'])
-router.include_router(token_router, prefix='/sessions', tags=['会话监控'])

backend/app/admin/api/v1/monitor/online.py

@@ -1,83 +0,0 @@
-import json
-
-from typing import Annotated
-
-from fastapi import APIRouter, Path, Query
-
-from backend.app.admin.schema.token import GetTokenDetail
-from backend.common.enums import StatusType
-from backend.common.response.response_schema import ResponseModel, ResponseSchemaModel, response_base
-from backend.common.security.jwt import DependsJwtAuth, DependsSuperUser, jwt_decode, revoke_token
-from backend.core.conf import settings
-from backend.database.redis import redis_client
-
-router = APIRouter()
-
-
-@router.get('', summary='获取在线用户', dependencies=[DependsJwtAuth])
-async def get_sessions(
-    username: Annotated[str | None, Query(description='用户名')] = None,
-) -> ResponseSchemaModel[list[GetTokenDetail]]:
-    token_keys = await redis_client.get_prefix(f'{settings.TOKEN_REDIS_PREFIX}:*')
-    online_clients = await redis_client.smembers(settings.TOKEN_ONLINE_REDIS_PREFIX)
-    data: list[GetTokenDetail] = []
-
-    def append_token_detail() -> None:
-        data.append(
-            token_detail.model_copy(
-                update={
-                    'username': extra_info.get('username', '未知'),
-                    'nickname': extra_info.get('nickname', '未知'),
-                    'ip': extra_info.get('ip', '未知'),
-                    'os': extra_info.get('os', '未知'),
-                    'browser': extra_info.get('browser', '未知'),
-                    'device': extra_info.get('device', '未知'),
-                    'last_login_time': extra_info.get('last_login_time', '未知'),
-                },
-            ),
-        )
-
-    for key in token_keys:
-        token = await redis_client.get(key)
-        token_payload = jwt_decode(token)
-        user_id = token_payload.id
-        session_uuid = token_payload.session_uuid
-        token_detail = GetTokenDetail(
-            id=user_id,
-            session_uuid=session_uuid,
-            username='未知',
-            nickname='未知',
-            ip='未知',
-            os='未知',
-            browser='未知',
-            device='未知',
-            status=StatusType.enable if session_uuid in online_clients else StatusType.disable,
-            last_login_time='未知',
-            expire_time=token_payload.expire_time,
-        )
-        extra_info = await redis_client.get(f'{settings.TOKEN_EXTRA_INFO_REDIS_PREFIX}:{user_id}:{session_uuid}')
-        if extra_info:
-            extra_info = json.loads(extra_info)
-            # 排除 swagger 登录生成的 token
-            if extra_info.get('swagger') is None:
-                if username is not None:
-                    if username == extra_info.get('username'):
-                        append_token_detail()
-                else:
-                    append_token_detail()
-        else:
-            data.append(token_detail)
-    return response_base.success(data=data)
-
-
-@router.delete(
-    '/{pk}',
-    summary='强制下线',
-    dependencies=[DependsSuperUser],
-)
-async def delete_session(
-    pk: Annotated[int, Path(description='用户 ID')],
-    session_uuid: Annotated[str, Query(description='会话 UUID')],
-) -> ResponseModel:
-    await revoke_token(pk, session_uuid)
-    return response_base.success()

backend/app/admin/api/v1/monitor/redis.py

@@ -1,16 +0,0 @@
-from fastapi import APIRouter
-
-from backend.common.response.response_schema import ResponseModel, response_base
-from backend.common.security.jwt import DependsJwtAuth
-from backend.utils.redis_info import redis_info
-
-router = APIRouter()
-
-
-@router.get('', summary='redis 监控', dependencies=[DependsJwtAuth])
-async def get_redis_info() -> ResponseModel:
-    data = {
-        'info': await redis_info.get_info(),
-        'stats': await redis_info.get_stats(),
-    }
-    return response_base.success(data=data)

backend/app/admin/api/v1/monitor/server.py

@@ -1,21 +0,0 @@
-from fastapi import APIRouter
-from starlette.concurrency import run_in_threadpool
-
-from backend.common.response.response_schema import ResponseModel, response_base
-from backend.common.security.jwt import DependsJwtAuth
-from backend.utils.server_info import server_info
-
-router = APIRouter()
-
-
-@router.get('', summary='server 监控', dependencies=[DependsJwtAuth])
-async def get_server_info() -> ResponseModel:
-    data = {
-        # 扔到线程池，避免阻塞
-        'cpu': await run_in_threadpool(server_info.get_cpu_info),
-        'mem': await run_in_threadpool(server_info.get_mem_info),
-        'sys': await run_in_threadpool(server_info.get_sys_info),
-        'disk': await run_in_threadpool(server_info.get_disk_info),
-        'service': await run_in_threadpool(server_info.get_service_info),
-    }
-    return response_base.success(data=data)

backend/app/admin/api/v1/sys/__init__.py

@@ -1,21 +1,11 @@
 from fastapi import APIRouter
 
-from backend.app.admin.api.v1.sys.data_rule import router as data_rule_router
-from backend.app.admin.api.v1.sys.data_scope import router as data_scope_router
-from backend.app.admin.api.v1.sys.dept import router as dept_router
 from backend.app.admin.api.v1.sys.file import router as file_router
-from backend.app.admin.api.v1.sys.menu import router as menu_router
 from backend.app.admin.api.v1.sys.plugin import router as plugin_router
-from backend.app.admin.api.v1.sys.role import router as role_router
 from backend.app.admin.api.v1.sys.user import router as user_router
 
 router = APIRouter(prefix='/sys')
 
-router.include_router(dept_router, prefix='/depts', tags=['系统部门'])
-router.include_router(menu_router, prefix='/menus', tags=['系统菜单'])
-router.include_router(role_router, prefix='/roles', tags=['系统角色'])
 router.include_router(user_router, prefix='/users', tags=['系统用户'])
-router.include_router(data_rule_router, prefix='/data-rules', tags=['系统数据规则'])
-router.include_router(data_scope_router, prefix='/data-scopes', tags=['系统数据范围'])
 router.include_router(file_router, prefix='/files', tags=['系统文件'])
 router.include_router(plugin_router, prefix='/plugins', tags=['系统插件'])

backend/app/admin/api/v1/sys/data_rule.py

@@ -1,112 +0,0 @@
-from typing import Annotated
-
-from fastapi import APIRouter, Depends, Path, Query
-
-from backend.app.admin.schema.data_rule import (
-    CreateDataRuleParam,
-    DeleteDataRuleParam,
-    GetDataRuleColumnDetail,
-    GetDataRuleDetail,
-    UpdateDataRuleParam,
-)
-from backend.app.admin.service.data_rule_service import data_rule_service
-from backend.common.pagination import DependsPagination, PageData
-from backend.common.response.response_schema import ResponseModel, ResponseSchemaModel, response_base
-from backend.common.security.jwt import DependsJwtAuth
-from backend.common.security.permission import RequestPermission
-from backend.common.security.rbac import DependsRBAC
-from backend.database.db import CurrentSession, CurrentSessionTransaction
-
-router = APIRouter()
-
-
-@router.get('/models', summary='获取数据规则可用模型', dependencies=[DependsJwtAuth])
-async def get_data_rule_models() -> ResponseSchemaModel[list[str]]:
-    models = await data_rule_service.get_models()
-    return response_base.success(data=models)
-
-
-@router.get('/models/{model}/columns', summary='获取数据规则可用模型列', dependencies=[DependsJwtAuth])
-async def get_data_rule_model_columns(
-    model: Annotated[str, Path(description='模型名称')],
-) -> ResponseSchemaModel[list[GetDataRuleColumnDetail]]:
-    models = await data_rule_service.get_columns(model=model)
-    return response_base.success(data=models)
-
-
-@router.get('/all', summary='获取所有数据规则', dependencies=[DependsJwtAuth])
-async def get_all_data_rules(db: CurrentSession) -> ResponseSchemaModel[list[GetDataRuleDetail]]:
-    data = await data_rule_service.get_all(db=db)
-    return response_base.success(data=data)
-
-
-@router.get('/{pk}', summary='获取数据规则详情', dependencies=[DependsJwtAuth])
-async def get_data_rule(
-    db: CurrentSession,
-    pk: Annotated[int, Path(description='数据规则 ID')],
-) -> ResponseSchemaModel[GetDataRuleDetail]:
-    data = await data_rule_service.get(db=db, pk=pk)
-    return response_base.success(data=data)
-
-
-@router.get(
-    '',
-    summary='分页获取所有数据规则',
-    dependencies=[
-        DependsJwtAuth,
-        DependsPagination,
-    ],
-)
-async def get_data_rules_paginated(
-    db: CurrentSession,
-    name: Annotated[str | None, Query(description='规则名称')] = None,
-) -> ResponseSchemaModel[PageData[GetDataRuleDetail]]:
-    page_data = await data_rule_service.get_list(db=db, name=name)
-    return response_base.success(data=page_data)
-
-
-@router.post(
-    '',
-    summary='创建数据规则',
-    dependencies=[
-        Depends(RequestPermission('data:rule:add')),
-        DependsRBAC,
-    ],
-)
-async def create_data_rule(db: CurrentSessionTransaction, obj: CreateDataRuleParam) -> ResponseModel:
-    await data_rule_service.create(db=db, obj=obj)
-    return response_base.success()
-
-
-@router.put(
-    '/{pk}',
-    summary='更新数据规则',
-    dependencies=[
-        Depends(RequestPermission('data:rule:edit')),
-        DependsRBAC,
-    ],
-)
-async def update_data_rule(
-    db: CurrentSessionTransaction,
-    pk: Annotated[int, Path(description='数据规则 ID')],
-    obj: UpdateDataRuleParam,
-) -> ResponseModel:
-    count = await data_rule_service.update(db=db, pk=pk, obj=obj)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()
-
-
-@router.delete(
-    '',
-    summary='批量删除数据规则',
-    dependencies=[
-        Depends(RequestPermission('data:rule:del')),
-        DependsRBAC,
-    ],
-)
-async def delete_data_rules(db: CurrentSessionTransaction, obj: DeleteDataRuleParam) -> ResponseModel:
-    count = await data_rule_service.delete(db=db, obj=obj)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()

backend/app/admin/api/v1/sys/data_scope.py

@@ -1,128 +0,0 @@
-from typing import Annotated
-
-from fastapi import APIRouter, Depends, Path, Query
-
-from backend.app.admin.schema.data_scope import (
-    CreateDataScopeParam,
-    DeleteDataScopeParam,
-    GetDataScopeDetail,
-    GetDataScopeWithRelationDetail,
-    UpdateDataScopeParam,
-    UpdateDataScopeRuleParam,
-)
-from backend.app.admin.service.data_scope_service import data_scope_service
-from backend.common.pagination import DependsPagination, PageData
-from backend.common.response.response_schema import ResponseModel, ResponseSchemaModel, response_base
-from backend.common.security.jwt import DependsJwtAuth
-from backend.common.security.permission import RequestPermission
-from backend.common.security.rbac import DependsRBAC
-from backend.database.db import CurrentSession, CurrentSessionTransaction
-
-router = APIRouter()
-
-
-@router.get('/all', summary='获取所有数据范围', dependencies=[DependsJwtAuth])
-async def get_all_data_scope(db: CurrentSession) -> ResponseSchemaModel[list[GetDataScopeDetail]]:
-    data = await data_scope_service.get_all(db=db)
-    return response_base.success(data=data)
-
-
-@router.get('/{pk}', summary='获取数据范围详情', dependencies=[DependsJwtAuth])
-async def get_data_scope(
-    db: CurrentSession,
-    pk: Annotated[int, Path(description='数据范围 ID')],
-) -> ResponseSchemaModel[GetDataScopeDetail]:
-    data = await data_scope_service.get(db=db, pk=pk)
-    return response_base.success(data=data)
-
-
-@router.get('/{pk}/rules', summary='获取数据范围所有规则', dependencies=[DependsJwtAuth])
-async def get_data_scope_rules(
-    db: CurrentSession,
-    pk: Annotated[int, Path(description='数据范围 ID')],
-) -> ResponseSchemaModel[GetDataScopeWithRelationDetail]:
-    data = await data_scope_service.get_rules(db=db, pk=pk)
-    return response_base.success(data=data)
-
-
-@router.get(
-    '',
-    summary='分页获取所有数据范围',
-    dependencies=[
-        DependsJwtAuth,
-        DependsPagination,
-    ],
-)
-async def get_data_scopes_paginated(
-    db: CurrentSession,
-    name: Annotated[str | None, Query(description='范围名称')] = None,
-    status: Annotated[int | None, Query(description='状态')] = None,
-) -> ResponseSchemaModel[PageData[GetDataScopeDetail]]:
-    page_data = await data_scope_service.get_list(db=db, name=name, status=status)
-    return response_base.success(data=page_data)
-
-
-@router.post(
-    '',
-    summary='创建数据范围',
-    dependencies=[
-        Depends(RequestPermission('data:scope:add')),
-        DependsRBAC,
-    ],
-)
-async def create_data_scope(db: CurrentSessionTransaction, obj: CreateDataScopeParam) -> ResponseModel:
-    await data_scope_service.create(db=db, obj=obj)
-    return response_base.success()
-
-
-@router.put(
-    '/{pk}',
-    summary='更新数据范围',
-    dependencies=[
-        Depends(RequestPermission('data:scope:edit')),
-        DependsRBAC,
-    ],
-)
-async def update_data_scope(
-    db: CurrentSessionTransaction,
-    pk: Annotated[int, Path(description='数据范围 ID')],
-    obj: UpdateDataScopeParam,
-) -> ResponseModel:
-    count = await data_scope_service.update(db=db, pk=pk, obj=obj)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()
-
-
-@router.put(
-    '/{pk}/rules',
-    summary='更新数据范围规则',
-    dependencies=[
-        Depends(RequestPermission('data:scope:rule:edit')),
-        DependsRBAC,
-    ],
-)
-async def update_data_scope_rules(
-    db: CurrentSessionTransaction,
-    pk: Annotated[int, Path(description='数据范围 ID')],
-    rule_ids: UpdateDataScopeRuleParam,
-) -> ResponseModel:
-    count = await data_scope_service.update_data_scope_rule(db=db, pk=pk, rule_ids=rule_ids)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()
-
-
-@router.delete(
-    '',
-    summary='批量删除数据范围',
-    dependencies=[
-        Depends(RequestPermission('data:scope:del')),
-        DependsRBAC,
-    ],
-)
-async def delete_data_scopes(db: CurrentSessionTransaction, obj: DeleteDataScopeParam) -> ResponseModel:
-    count = await data_scope_service.delete(db=db, obj=obj)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()

backend/app/admin/api/v1/sys/dept.py

@@ -1,81 +0,0 @@
-from typing import Annotated
-
-from fastapi import APIRouter, Depends, Path, Query, Request
-
-from backend.app.admin.schema.dept import CreateDeptParam, GetDeptDetail, GetDeptTree, UpdateDeptParam
-from backend.app.admin.service.dept_service import dept_service
-from backend.common.response.response_schema import ResponseModel, ResponseSchemaModel, response_base
-from backend.common.security.jwt import DependsJwtAuth
-from backend.common.security.permission import RequestPermission
-from backend.common.security.rbac import DependsRBAC
-from backend.database.db import CurrentSession, CurrentSessionTransaction
-
-router = APIRouter()
-
-
-@router.get('/{pk}', summary='获取部门详情', dependencies=[DependsJwtAuth])
-async def get_dept(
-    db: CurrentSession, pk: Annotated[int, Path(description='部门 ID')]
-) -> ResponseSchemaModel[GetDeptDetail]:
-    data = await dept_service.get(db=db, pk=pk)
-    return response_base.success(data=data)
-
-
-@router.get('', summary='获取部门树', dependencies=[DependsJwtAuth])
-async def get_dept_tree(
-    db: CurrentSession,
-    request: Request,
-    name: Annotated[str | None, Query(description='部门名称')] = None,
-    leader: Annotated[str | None, Query(description='部门负责人')] = None,
-    phone: Annotated[str | None, Query(description='联系电话')] = None,
-    status: Annotated[int | None, Query(description='状态')] = None,
-) -> ResponseSchemaModel[list[GetDeptTree]]:
-    dept = await dept_service.get_tree(
-        db=db, request_user=request.user, name=name, leader=leader, phone=phone, status=status
-    )
-    return response_base.success(data=dept)
-
-
-@router.post(
-    '',
-    summary='创建部门',
-    dependencies=[
-        Depends(RequestPermission('sys:dept:add')),
-        DependsRBAC,
-    ],
-)
-async def create_dept(db: CurrentSessionTransaction, obj: CreateDeptParam) -> ResponseModel:
-    await dept_service.create(db=db, obj=obj)
-    return response_base.success()
-
-
-@router.put(
-    '/{pk}',
-    summary='更新部门',
-    dependencies=[
-        Depends(RequestPermission('sys:dept:edit')),
-        DependsRBAC,
-    ],
-)
-async def update_dept(
-    db: CurrentSessionTransaction, pk: Annotated[int, Path(description='部门 ID')], obj: UpdateDeptParam
-) -> ResponseModel:
-    count = await dept_service.update(db=db, pk=pk, obj=obj)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()
-
-
-@router.delete(
-    '/{pk}',
-    summary='删除部门',
-    dependencies=[
-        Depends(RequestPermission('sys:dept:del')),
-        DependsRBAC,
-    ],
-)
-async def delete_dept(db: CurrentSessionTransaction, pk: Annotated[int, Path(description='部门 ID')]) -> ResponseModel:
-    count = await dept_service.delete(db=db, pk=pk)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()

backend/app/admin/api/v1/sys/file.py

@@ -1,11 +1,10 @@
 from typing import Annotated
 
-from fastapi import APIRouter, Depends, File, UploadFile
+from fastapi import APIRouter, File, UploadFile
 
 from backend.common.dataclasses import UploadUrl
 from backend.common.response.response_schema import ResponseSchemaModel, response_base
-from backend.common.security.permission import RequestPermission
+from backend.common.security.jwt import DependsJwtAuth
-from backend.common.security.rbac import DependsRBAC
 from backend.utils.file_ops import upload_file, upload_file_verify
 
 router = APIRouter()
@@ -14,10 +13,7 @@ router = APIRouter()
 @router.post(
     '/upload',
     summary='本地文件上传',
-    dependencies=[
+    dependencies=[DependsJwtAuth],
-        Depends(RequestPermission('sys:file:upload')),
-        DependsRBAC,
-    ],
 )
 async def upload_files(file: Annotated[UploadFile, File()]) -> ResponseSchemaModel[UploadUrl]:
     upload_file_verify(file)

backend/app/admin/api/v1/sys/menu.py

@@ -1,82 +0,0 @@
-from typing import Annotated, Any
-
-from fastapi import APIRouter, Depends, Path, Query, Request
-
-from backend.app.admin.schema.menu import CreateMenuParam, GetMenuDetail, GetMenuTree, UpdateMenuParam
-from backend.app.admin.service.menu_service import menu_service
-from backend.common.response.response_schema import ResponseModel, ResponseSchemaModel, response_base
-from backend.common.security.jwt import DependsJwtAuth
-from backend.common.security.permission import RequestPermission
-from backend.common.security.rbac import DependsRBAC
-from backend.database.db import CurrentSession, CurrentSessionTransaction
-
-router = APIRouter()
-
-
-@router.get('/sidebar', summary='获取用户菜单侧边栏', description='已适配 vben admin v5', dependencies=[DependsJwtAuth])
-async def get_user_sidebar(db: CurrentSession, request: Request) -> ResponseSchemaModel[list[dict[str, Any] | None]]:
-    menu = await menu_service.get_sidebar(db=db, request=request)
-    return response_base.success(data=menu)
-
-
-@router.get('/{pk}', summary='获取菜单详情', dependencies=[DependsJwtAuth])
-async def get_menu(
-    db: CurrentSession, pk: Annotated[int, Path(description='菜单 ID')]
-) -> ResponseSchemaModel[GetMenuDetail]:
-    data = await menu_service.get(db=db, pk=pk)
-    return response_base.success(data=data)
-
-
-@router.get('', summary='获取菜单树', dependencies=[DependsJwtAuth])
-async def get_menu_tree(
-    db: CurrentSession,
-    title: Annotated[str | None, Query(description='菜单标题')] = None,
-    status: Annotated[int | None, Query(description='状体')] = None,
-) -> ResponseSchemaModel[list[GetMenuTree]]:
-    menu = await menu_service.get_tree(db=db, title=title, status=status)
-    return response_base.success(data=menu)
-
-
-@router.post(
-    '',
-    summary='创建菜单',
-    dependencies=[
-        Depends(RequestPermission('sys:menu:add')),
-        DependsRBAC,
-    ],
-)
-async def create_menu(db: CurrentSessionTransaction, obj: CreateMenuParam) -> ResponseModel:
-    await menu_service.create(db=db, obj=obj)
-    return response_base.success()
-
-
-@router.put(
-    '/{pk}',
-    summary='更新菜单',
-    dependencies=[
-        Depends(RequestPermission('sys:menu:edit')),
-        DependsRBAC,
-    ],
-)
-async def update_menu(
-    db: CurrentSessionTransaction, pk: Annotated[int, Path(description='菜单 ID')], obj: UpdateMenuParam
-) -> ResponseModel:
-    count = await menu_service.update(db=db, pk=pk, obj=obj)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()
-
-
-@router.delete(
-    '/{pk}',
-    summary='删除菜单',
-    dependencies=[
-        Depends(RequestPermission('sys:menu:del')),
-        DependsRBAC,
-    ],
-)
-async def delete_menu(db: CurrentSessionTransaction, pk: Annotated[int, Path(description='菜单 ID')]) -> ResponseModel:
-    count = await menu_service.delete(db=db, pk=pk)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()

backend/app/admin/api/v1/sys/plugin.py

@@ -1,6 +1,6 @@
 from typing import Annotated, Any
 
-from fastapi import APIRouter, Depends, File, Path, UploadFile
+from fastapi import APIRouter, File, Path, UploadFile
 from fastapi.params import Query
 from starlette.responses import StreamingResponse
 
@@ -8,20 +8,18 @@ from backend.app.admin.service.plugin_service import plugin_service
 from backend.common.enums import PluginType
 from backend.common.response.response_code import CustomResponse
 from backend.common.response.response_schema import ResponseModel, ResponseSchemaModel, response_base
-from backend.common.security.jwt import DependsJwtAuth
+from backend.common.security.jwt import DependsSuperUser
-from backend.common.security.permission import RequestPermission
-from backend.common.security.rbac import DependsRBAC
 
 router = APIRouter()
 
 
-@router.get('', summary='获取所有插件', dependencies=[DependsJwtAuth])
+@router.get('', summary='获取所有插件', dependencies=[DependsSuperUser])
 async def get_all_plugins() -> ResponseSchemaModel[list[dict[str, Any]]]:
     plugins = await plugin_service.get_all()
     return response_base.success(data=plugins)
 
 
-@router.get('/changed', summary='是否存在插件变更', dependencies=[DependsJwtAuth])
+@router.get('/changed', summary='是否存在插件变更', dependencies=[DependsSuperUser])
 async def plugin_changed() -> ResponseSchemaModel[bool]:
     plugins = await plugin_service.changed()
     return response_base.success(data=bool(plugins))
@@ -30,11 +28,8 @@ async def plugin_changed() -> ResponseSchemaModel[bool]:
 @router.post(
     '',
     summary='安装插件',
-    description='使用插件 zip 压缩包或 git 仓库地址进行安装',
+    description='使用插件 zip 压缩包或 git 仓库地址进行安装（仅开发环境）',
-    dependencies=[
+    dependencies=[DependsSuperUser],
-        Depends(RequestPermission('sys:plugin:install')),
-        DependsRBAC,
-    ],
 )
 async def install_plugin(
     type: Annotated[PluginType, Query(description='插件类型')],
@@ -53,11 +48,8 @@ async def install_plugin(
 @router.delete(
     '/{plugin}',
     summary='卸载插件',
-    description='此操作会直接删除插件依赖，但不会直接删除插件，而是将插件移动到备份目录',
+    description='此操作会直接删除插件依赖，但不会直接删除插件，而是将插件移动到备份目录（仅开发环境）',
-    dependencies=[
+    dependencies=[DependsSuperUser],
-        Depends(RequestPermission('sys:plugin:uninstall')),
-        DependsRBAC,
-    ],
 )
 async def uninstall_plugin(plugin: Annotated[str, Path(description='插件名称')]) -> ResponseModel:
     await plugin_service.uninstall(plugin=plugin)
@@ -66,20 +58,13 @@ async def uninstall_plugin(plugin: Annotated[str, Path(description='插件名称
     )
 
 
-@router.put(
+@router.put('/{plugin}/status', summary='更新插件状态', dependencies=[DependsSuperUser])
-    '/{plugin}/status',
-    summary='更新插件状态',
-    dependencies=[
-        Depends(RequestPermission('sys:plugin:edit')),
-        DependsRBAC,
-    ],
-)
 async def update_plugin_status(plugin: Annotated[str, Path(description='插件名称')]) -> ResponseModel:
     await plugin_service.update_status(plugin=plugin)
     return response_base.success()
 
 
-@router.get('/{plugin}', summary='下载插件', dependencies=[DependsJwtAuth])
+@router.get('/{plugin}', summary='下载插件', dependencies=[DependsSuperUser])
 async def download_plugin(plugin: Annotated[str, Path(description='插件名称')]) -> StreamingResponse:
     bio = await plugin_service.build(plugin=plugin)
     return StreamingResponse(

backend/app/admin/api/v1/sys/role.py

@@ -1,154 +0,0 @@
-from typing import Annotated
-
-from fastapi import APIRouter, Depends, Path, Query
-
-from backend.app.admin.schema.menu import GetMenuTree
-from backend.app.admin.schema.role import (
-    CreateRoleParam,
-    DeleteRoleParam,
-    GetRoleDetail,
-    GetRoleWithRelationDetail,
-    UpdateRoleMenuParam,
-    UpdateRoleParam,
-    UpdateRoleScopeParam,
-)
-from backend.app.admin.service.role_service import role_service
-from backend.common.pagination import DependsPagination, PageData
-from backend.common.response.response_schema import ResponseModel, ResponseSchemaModel, response_base
-from backend.common.security.jwt import DependsJwtAuth
-from backend.common.security.permission import RequestPermission
-from backend.common.security.rbac import DependsRBAC
-from backend.database.db import CurrentSession, CurrentSessionTransaction
-
-router = APIRouter()
-
-
-@router.get('/all', summary='获取所有角色', dependencies=[DependsJwtAuth])
-async def get_all_roles(db: CurrentSession) -> ResponseSchemaModel[list[GetRoleDetail]]:
-    data = await role_service.get_all(db=db)
-    return response_base.success(data=data)
-
-
-@router.get('/{pk}/menus', summary='获取角色菜单树', dependencies=[DependsJwtAuth])
-async def get_role_menu_tree(
-    db: CurrentSession,
-    pk: Annotated[int, Path(description='角色 ID')],
-) -> ResponseSchemaModel[list[GetMenuTree] | None]:
-    menu = await role_service.get_menu_tree(db=db, pk=pk)
-    return response_base.success(data=menu)
-
-
-@router.get('/{pk}/scopes', summary='获取角色所有数据范围', dependencies=[DependsJwtAuth])
-async def get_role_scopes(
-    db: CurrentSession, pk: Annotated[int, Path(description='角色 ID')]
-) -> ResponseSchemaModel[list[int]]:
-    rule = await role_service.get_scopes(db=db, pk=pk)
-    return response_base.success(data=rule)
-
-
-@router.get('/{pk}', summary='获取角色详情', dependencies=[DependsJwtAuth])
-async def get_role(
-    db: CurrentSession, pk: Annotated[int, Path(description='角色 ID')]
-) -> ResponseSchemaModel[GetRoleWithRelationDetail]:
-    data = await role_service.get(db=db, pk=pk)
-    return response_base.success(data=data)
-
-
-@router.get(
-    '',
-    summary='分页获取所有角色',
-    dependencies=[
-        DependsJwtAuth,
-        DependsPagination,
-    ],
-)
-async def get_roles_paginated(
-    db: CurrentSession,
-    name: Annotated[str | None, Query(description='角色名称')] = None,
-    status: Annotated[int | None, Query(description='状态')] = None,
-) -> ResponseSchemaModel[PageData[GetRoleDetail]]:
-    page_data = await role_service.get_list(db=db, name=name, status=status)
-    return response_base.success(data=page_data)
-
-
-@router.post(
-    '',
-    summary='创建角色',
-    dependencies=[
-        Depends(RequestPermission('sys:role:add')),
-        DependsRBAC,
-    ],
-)
-async def create_role(db: CurrentSessionTransaction, obj: CreateRoleParam) -> ResponseModel:
-    await role_service.create(db=db, obj=obj)
-    return response_base.success()
-
-
-@router.put(
-    '/{pk}',
-    summary='更新角色',
-    dependencies=[
-        Depends(RequestPermission('sys:role:edit')),
-        DependsRBAC,
-    ],
-)
-async def update_role(
-    db: CurrentSessionTransaction, pk: Annotated[int, Path(description='角色 ID')], obj: UpdateRoleParam
-) -> ResponseModel:
-    count = await role_service.update(db=db, pk=pk, obj=obj)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()
-
-
-@router.put(
-    '/{pk}/menus',
-    summary='更新角色菜单',
-    dependencies=[
-        Depends(RequestPermission('sys:role:menu:edit')),
-        DependsRBAC,
-    ],
-)
-async def update_role_menus(
-    db: CurrentSessionTransaction,
-    pk: Annotated[int, Path(description='角色 ID')],
-    menu_ids: UpdateRoleMenuParam,
-) -> ResponseModel:
-    count = await role_service.update_role_menu(db=db, pk=pk, menu_ids=menu_ids)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()
-
-
-@router.put(
-    '/{pk}/scopes',
-    summary='更新角色数据范围',
-    dependencies=[
-        Depends(RequestPermission('sys:role:scope:edit')),
-        DependsRBAC,
-    ],
-)
-async def update_role_scopes(
-    db: CurrentSessionTransaction,
-    pk: Annotated[int, Path(description='角色 ID')],
-    scope_ids: UpdateRoleScopeParam,
-) -> ResponseModel:
-    count = await role_service.update_role_scope(db=db, pk=pk, scope_ids=scope_ids)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()
-
-
-@router.delete(
-    '',
-    summary='批量删除角色',
-    dependencies=[
-        Depends(RequestPermission('sys:role:del')),
-        DependsRBAC,
-    ],
-)
-async def delete_roles(db: CurrentSessionTransaction, obj: DeleteRoleParam) -> ResponseModel:
-    count = await role_service.delete(db=db, obj=obj)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()

backend/app/admin/api/v1/sys/user.py

@@ -1,12 +1,10 @@
 from typing import Annotated
 
-from fastapi import APIRouter, Body, Depends, Path, Query, Request
+from fastapi import APIRouter, Body, Path, Query, Request
 
-from backend.app.admin.schema.role import GetRoleDetail
 from backend.app.admin.schema.user import (
     AddUserParam,
-    GetCurrentUserInfoWithRelationDetail,
+    GetUserInfoDetail,
-    GetUserInfoWithRelationDetail,
     ResetPasswordParam,
     UpdateUserParam,
 )
@@ -15,15 +13,13 @@ from backend.common.enums import UserPermissionType
 from backend.common.pagination import DependsPagination, PageData
 from backend.common.response.response_schema import ResponseModel, ResponseSchemaModel, response_base
 from backend.common.security.jwt import DependsJwtAuth, DependsSuperUser
-from backend.common.security.permission import RequestPermission
-from backend.common.security.rbac import DependsRBAC
 from backend.database.db import CurrentSession, CurrentSessionTransaction
 
 router = APIRouter()
 
 
 @router.get('/me', summary='获取当前用户信息', dependencies=[DependsJwtAuth])
-async def get_current_user(request: Request) -> ResponseSchemaModel[GetCurrentUserInfoWithRelationDetail]:
+async def get_current_user(request: Request) -> ResponseSchemaModel[GetUserInfoDetail]:
     data = request.user.model_dump()
     return response_base.success(data=data)
 
@@ -32,19 +28,11 @@ async def get_current_user(request: Request) -> ResponseSchemaModel[GetCurrentUs
 async def get_userinfo(
     db: CurrentSession,
     pk: Annotated[int, Path(description='用户 ID')],
-) -> ResponseSchemaModel[GetUserInfoWithRelationDetail]:
+) -> ResponseSchemaModel[GetUserInfoDetail]:
     data = await user_service.get_userinfo(db=db, pk=pk)
     return response_base.success(data=data)
 
 
-@router.get('/{pk}/roles', summary='获取用户所有角色', dependencies=[DependsJwtAuth])
-async def get_user_roles(
-    db: CurrentSession, pk: Annotated[int, Path(description='用户 ID')]
-) -> ResponseSchemaModel[list[GetRoleDetail]]:
-    data = await user_service.get_roles(db=db, pk=pk)
-    return response_base.success(data=data)
-
-
 @router.get(
     '',
     summary='分页获取所有用户',
@@ -55,19 +43,16 @@ async def get_user_roles(
 )
 async def get_users_paginated(
     db: CurrentSession,
-    dept: Annotated[int | None, Query(description='部门 ID')] = None,
     username: Annotated[str | None, Query(description='用户名')] = None,
     phone: Annotated[str | None, Query(description='手机号')] = None,
     status: Annotated[int | None, Query(description='状态')] = None,
-) -> ResponseSchemaModel[PageData[GetUserInfoWithRelationDetail]]:
+) -> ResponseSchemaModel[PageData[GetUserInfoDetail]]:
-    page_data = await user_service.get_list(db=db, dept=dept, username=username, phone=phone, status=status)
+    page_data = await user_service.get_list(db=db, username=username, phone=phone, status=status)
     return response_base.success(data=page_data)
 
 
 @router.post('', summary='创建用户', dependencies=[DependsSuperUser])
-async def create_user(
+async def create_user(db: CurrentSessionTransaction, obj: AddUserParam) -> ResponseSchemaModel[GetUserInfoDetail]:
-    db: CurrentSessionTransaction, obj: AddUserParam
-) -> ResponseSchemaModel[GetUserInfoWithRelationDetail]:
     await user_service.create(db=db, obj=obj)
     data = await user_service.get_userinfo(db=db, username=obj.username)
     return response_base.success(data=data)
@@ -148,10 +133,9 @@ async def update_user_avatar(
 async def update_user_email(
     db: CurrentSessionTransaction,
     request: Request,
-    captcha: Annotated[str, Body(embed=True, description='邮箱验证码')],
     email: Annotated[str, Body(embed=True, description='用户邮箱')],
 ) -> ResponseModel:
-    count = await user_service.update_email(db=db, user_id=request.user.id, captcha=captcha, email=email)
+    count = await user_service.update_email(db=db, user_id=request.user.id, email=email)
     if count > 0:
         return response_base.success()
     return response_base.fail()
@@ -160,10 +144,7 @@ async def update_user_email(
 @router.delete(
     path='/{pk}',
     summary='删除用户',
-    dependencies=[
+    dependencies=[DependsSuperUser],
-        Depends(RequestPermission('sys:user:del')),
-        DependsRBAC,
-    ],
 )
 async def delete_user(db: CurrentSessionTransaction, pk: Annotated[int, Path(description='用户 ID')]) -> ResponseModel:
     count = await user_service.delete(db=db, pk=pk)

backend/app/admin/crud/crud_data_rule.py

@@ -1,89 +0,0 @@
-from collections.abc import Sequence
-
-from sqlalchemy import Select
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy_crud_plus import CRUDPlus
-
-from backend.app.admin.model import DataRule
-from backend.app.admin.schema.data_rule import CreateDataRuleParam, UpdateDataRuleParam
-
-
-class CRUDDataRule(CRUDPlus[DataRule]):
-    """数据规则数据库操作类"""
-
-    async def get(self, db: AsyncSession, pk: int) -> DataRule | None:
-        """
-        获取规则详情
-
-        :param db: 数据库会话
-        :param pk: 规则 ID
-        :return:
-        """
-        return await self.select_model(db, pk)
-
-    async def get_select(self, name: str | None) -> Select:
-        """
-        获取规则列表查询表达式
-
-        :param name: 规则名称
-        :return:
-        """
-        filters = {}
-
-        if name is not None:
-            filters['name__like'] = f'%{name}%'
-
-        return await self.select_order('id', **filters)
-
-    async def get_by_name(self, db: AsyncSession, name: str) -> DataRule | None:
-        """
-        通过名称获取规则
-
-        :param db: 数据库会话
-        :param name: 规则名称
-        :return:
-        """
-        return await self.select_model_by_column(db, name=name)
-
-    async def get_all(self, db: AsyncSession) -> Sequence[DataRule]:
-        """
-        获取所有规则
-
-        :param db: 数据库会话
-        :return:
-        """
-        return await self.select_models(db)
-
-    async def create(self, db: AsyncSession, obj: CreateDataRuleParam) -> None:
-        """
-        创建规则
-
-        :param db: 数据库会话
-        :param obj: 创建规则参数
-        :return:
-        """
-        await self.create_model(db, obj)
-
-    async def update(self, db: AsyncSession, pk: int, obj: UpdateDataRuleParam) -> int:
-        """
-        更新规则
-
-        :param db: 数据库会话
-        :param pk: 规则 ID
-        :param obj: 更新规则参数
-        :return:
-        """
-        return await self.update_model(db, pk, obj)
-
-    async def delete(self, db: AsyncSession, pks: list[int]) -> int:
-        """
-        批量删除规则
-
-        :param db: 数据库会话
-        :param pks: 规则 ID 列表
-        :return:
-        """
-        return await self.delete_model_by_column(db, allow_multiple=True, id__in=pks)
-
-
-data_rule_dao: CRUDDataRule = CRUDDataRule(DataRule)

backend/app/admin/crud/crud_data_scope.py

@@ -1,139 +0,0 @@
-from collections.abc import Sequence
-from typing import Any
-
-from sqlalchemy import Select, delete, insert
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy_crud_plus import CRUDPlus, JoinConfig
-
-from backend.app.admin.model import DataRule, DataScope, data_scope_rule
-from backend.app.admin.schema.data_scope import (
-    CreateDataScopeParam,
-    CreateDataScopeRuleParam,
-    UpdateDataScopeParam,
-    UpdateDataScopeRuleParam,
-)
-from backend.utils.serializers import select_join_serialize
-
-
-class CRUDDataScope(CRUDPlus[DataScope]):
-    """数据范围数据库操作类"""
-
-    async def get(self, db: AsyncSession, pk: int) -> DataScope | None:
-        """
-        获取数据范围详情
-
-        :param db: 数据库会话
-        :param pk: 范围 ID
-        :return:
-        """
-        return await self.select_model(db, pk)
-
-    async def get_by_name(self, db: AsyncSession, name: str) -> DataScope | None:
-        """
-        通过名称获取数据范围
-
-        :param db: 数据库会话
-        :param name: 范围名称
-        :return:
-        """
-        return await self.select_model_by_column(db, name=name)
-
-    async def get_join(self, db: AsyncSession, pk: int) -> Any:
-        """
-        获取数据范围关联数据
-
-        :param db: 数据库会话
-        :param pk: 范围 ID
-        :return:
-        """
-        result = await self.select_models(
-            db,
-            id=pk,
-            join_conditions=[
-                JoinConfig(model=data_scope_rule, join_on=data_scope_rule.c.data_scope_id == self.model.id),
-                JoinConfig(model=DataRule, join_on=DataRule.id == data_scope_rule.c.data_rule_id, fill_result=True),
-            ],
-        )
-
-        return select_join_serialize(result, relationships=['DataScope-m2m-DataRule:rules'])
-
-    async def get_all(self, db: AsyncSession) -> Sequence[DataScope]:
-        """
-        获取所有数据范围
-
-        :param db: 数据库会话
-        :return:
-        """
-        return await self.select_models(db)
-
-    async def get_select(self, name: str | None, status: int | None) -> Select:
-        """
-        获取数据范围列表查询表达式
-
-        :param name: 范围名称
-        :param status: 范围状态
-        :return:
-        """
-        filters = {}
-
-        if name is not None:
-            filters['name__like'] = f'%{name}%'
-        if status is not None:
-            filters['status'] = status
-
-        return await self.select_order('id', **filters)
-
-    async def create(self, db: AsyncSession, obj: CreateDataScopeParam) -> None:
-        """
-        创建数据范围
-
-        :param db: 数据库会话
-        :param obj: 创建数据范围参数
-        :return:
-        """
-        await self.create_model(db, obj)
-
-    async def update(self, db: AsyncSession, pk: int, obj: UpdateDataScopeParam) -> int:
-        """
-        更新数据范围
-
-        :param db: 数据库会话
-        :param pk: 范围 ID
-        :param obj: 更新数据范围参数
-        :return:
-        """
-        return await self.update_model(db, pk, obj)
-
-    @staticmethod
-    async def update_rules(db: AsyncSession, pk: int, rule_ids: UpdateDataScopeRuleParam) -> int:
-        """
-        更新数据范围规则
-
-        :param db: 数据库会话
-        :param pk: 范围 ID
-        :param rule_ids: 数据规则 ID 列表
-        :return:
-        """
-        data_scope_rule_stmt = delete(data_scope_rule).where(data_scope_rule.c.data_scope_id == pk)
-        await db.execute(data_scope_rule_stmt)
-
-        data_scope_rule_data = [
-            CreateDataScopeRuleParam(data_scope_id=pk, data_rule_id=rule_id).model_dump() for rule_id in rule_ids.rules
-        ]
-        data_scope_rule_stmt = insert(data_scope_rule)
-        await db.execute(data_scope_rule_stmt, data_scope_rule_data)
-
-        return len(rule_ids.rules)
-
-    async def delete(self, db: AsyncSession, pks: list[int]) -> int:
-        """
-        批量删除数据范围
-
-        :param db: 数据库会话
-        :param pks: 范围 ID 列表
-        :return:
-        """
-        return await self.delete_model_by_column(db, allow_multiple=True, id__in=pks)
-
-
-data_scope_dao: CRUDDataScope = CRUDDataScope(DataScope)

backend/app/admin/crud/crud_dept.py

@@ -1,128 +0,0 @@
-from collections.abc import Sequence
-from typing import Any
-
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy_crud_plus import CRUDPlus, JoinConfig
-
-from backend.app.admin.model import Dept, User
-from backend.app.admin.schema.dept import CreateDeptParam, UpdateDeptParam
-from backend.app.admin.schema.user import GetUserInfoWithRelationDetail
-from backend.common.security.permission import filter_data_permission
-from backend.utils.serializers import select_join_serialize
-
-
-class CRUDDept(CRUDPlus[Dept]):
-    """部门数据库操作类"""
-
-    async def get(self, db: AsyncSession, dept_id: int) -> Dept | None:
-        """
-        获取部门详情
-
-        :param db: 数据库会话
-        :param dept_id: 部门 ID
-        :return:
-        """
-        return await self.select_model_by_column(db, id=dept_id, del_flag=False)
-
-    async def get_by_name(self, db: AsyncSession, name: str) -> Dept | None:
-        """
-        通过名称获取部门
-
-        :param db: 数据库会话
-        :param name: 部门名称
-        :return:
-        """
-        return await self.select_model_by_column(db, name=name, del_flag=False)
-
-    async def get_all(
-        self,
-        db: AsyncSession,
-        request_user: GetUserInfoWithRelationDetail,
-        name: str | None,
-        leader: str | None,
-        phone: str | None,
-        status: int | None,
-    ) -> Sequence[Dept]:
-        """
-        获取所有部门
-
-        :param db: 数据库会话
-        :param request_user: 请求用户
-        :param name: 部门名称
-        :param leader: 负责人
-        :param phone: 联系电话
-        :param status: 部门状态
-        :return:
-        """
-        filters = {'del_flag': False}
-
-        if name is not None:
-            filters['name__like'] = f'%{name}%'
-        if leader is not None:
-            filters['leader__like'] = f'%{leader}%'
-        if phone is not None:
-            filters['phone__startswith'] = phone
-        if status is not None:
-            filters['status'] = status
-
-        data_filter = filter_data_permission(request_user)
-        return await self.select_models_order(db, 'sort', 'desc', data_filter, **filters)
-
-    async def create(self, db: AsyncSession, obj: CreateDeptParam) -> None:
-        """
-        创建部门
-
-        :param db: 数据库会话
-        :param obj: 创建部门参数
-        :return:
-        """
-        await self.create_model(db, obj)
-
-    async def update(self, db: AsyncSession, dept_id: int, obj: UpdateDeptParam) -> int:
-        """
-        更新部门
-
-        :param db: 数据库会话
-        :param dept_id: 部门 ID
-        :param obj: 更新部门参数
-        :return:
-        """
-        return await self.update_model(db, dept_id, obj)
-
-    async def delete(self, db: AsyncSession, dept_id: int) -> int:
-        """
-        删除部门
-
-        :param db: 数据库会话
-        :param dept_id: 部门 ID
-        :return:
-        """
-        return await self.delete_model_by_column(db, id=dept_id, logical_deletion=True, deleted_flag_column='del_flag')
-
-    async def get_join(self, db: AsyncSession, dept_id: int) -> Any | None:
-        """
-        获取部门及关联数据
-
-        :param db: 数据库会话
-        :param dept_id: 部门 ID
-        :return:
-        """
-        result = await self.select_model(
-            db,
-            dept_id,
-            join_conditions=[JoinConfig(model=User, join_on=User.dept_id == self.model.id, fill_result=True)],
-        )
-        return select_join_serialize(result, relationships=['Dept-o2m-User'])
-
-    async def get_children(self, db: AsyncSession, dept_id: int) -> Sequence[Dept | None]:
-        """
-        获取子部门列表
-
-        :param db: 数据库会话
-        :param dept_id: 部门 ID
-        :return:
-        """
-        return await self.select_models(db, parent_id=dept_id, del_flag=False)
-
-
-dept_dao: CRUDDept = CRUDDept(Dept)

backend/app/admin/crud/crud_login_log.py

@@ -1,64 +0,0 @@
-from sqlalchemy import Select
-from sqlalchemy import delete as sa_delete
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy_crud_plus import CRUDPlus
-
-from backend.app.admin.model import LoginLog
-from backend.app.admin.schema.login_log import CreateLoginLogParam
-
-
-class CRUDLoginLog(CRUDPlus[LoginLog]):
-    """登录日志数据库操作类"""
-
-    async def get_select(self, username: str | None, status: int | None, ip: str | None) -> Select:
-        """
-        获取登录日志列表查询表达式
-
-        :param username: 用户名
-        :param status: 登录状态
-        :param ip: IP 地址
-        :return:
-        """
-        filters = {}
-
-        if username is not None:
-            filters['username__like'] = f'%{username}%'
-        if status is not None:
-            filters['status'] = status
-        if ip is not None:
-            filters['ip__like'] = f'%{ip}%'
-
-        return await self.select_order('created_time', 'desc', **filters)
-
-    async def create(self, db: AsyncSession, obj: CreateLoginLogParam) -> None:
-        """
-        创建登录日志
-
-        :param db: 数据库会话
-        :param obj: 创建登录日志参数
-        :return:
-        """
-        await self.create_model(db, obj, commit=True)
-
-    async def delete(self, db: AsyncSession, pks: list[int]) -> int:
-        """
-        批量删除登录日志
-
-        :param db: 数据库会话
-        :param pks: 登录日志 ID 列表
-        :return:
-        """
-        return await self.delete_model_by_column(db, allow_multiple=True, id__in=pks)
-
-    @staticmethod
-    async def delete_all(db: AsyncSession) -> None:
-        """
-        删除所有日志
-
-        :param db: 数据库会话
-        :return:
-        """
-        await db.execute(sa_delete(LoginLog))
-
-
-login_log_dao: CRUDLoginLog = CRUDLoginLog(LoginLog)

backend/app/admin/crud/crud_menu.py

@@ -1,112 +0,0 @@
-from collections.abc import Sequence
-
-from sqlalchemy import delete
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy_crud_plus import CRUDPlus
-
-from backend.app.admin.model import Menu, role_menu
-from backend.app.admin.schema.menu import CreateMenuParam, UpdateMenuParam
-
-
-class CRUDMenu(CRUDPlus[Menu]):
-    """菜单数据库操作类"""
-
-    async def get(self, db: AsyncSession, menu_id: int) -> Menu | None:
-        """
-        获取菜单详情
-
-        :param db: 数据库会话
-        :param menu_id: 菜单 ID
-        :return:
-        """
-        return await self.select_model(db, menu_id)
-
-    async def get_by_title(self, db: AsyncSession, title: str) -> Menu | None:
-        """
-        通过标题获取菜单
-
-        :param db: 数据库会话
-        :param title: 菜单标题
-        :return:
-        """
-        return await self.select_model_by_column(db, title=title, type__ne=2)
-
-    async def get_all(self, db: AsyncSession, title: str | None, status: int | None) -> Sequence[Menu]:
-        """
-        获取菜单列表
-
-        :param db: 数据库会话
-        :param title: 菜单标题
-        :param status: 菜单状态
-        :return:
-        """
-        filters = {}
-
-        if title is not None:
-            filters['title__like'] = f'%{title}%'
-        if status is not None:
-            filters['status'] = status
-
-        return await self.select_models_order(db, 'sort', **filters)
-
-    async def get_sidebar(self, db: AsyncSession, menu_ids: list[int] | None) -> Sequence[Menu]:
-        """
-        获取用户的菜单侧边栏
-
-        :param db: 数据库会话
-        :param menu_ids: 菜单 ID 列表
-        :return:
-        """
-        filters = {'type__in': [0, 1, 3, 4]}
-
-        if menu_ids:
-            filters['id__in'] = menu_ids
-
-        return await self.select_models_order(db, 'sort', 'asc', **filters)
-
-    async def create(self, db: AsyncSession, obj: CreateMenuParam) -> None:
-        """
-        创建菜单
-
-        :param db: 数据库会话
-        :param obj: 创建菜单参数
-        :return:
-        """
-        await self.create_model(db, obj)
-
-    async def update(self, db: AsyncSession, menu_id: int, obj: UpdateMenuParam) -> int:
-        """
-        更新菜单
-
-        :param db: 数据库会话
-        :param menu_id: 菜单 ID
-        :param obj: 更新菜单参数
-        :return:
-        """
-        return await self.update_model(db, menu_id, obj)
-
-    async def delete(self, db: AsyncSession, menu_id: int) -> int:
-        """
-        删除菜单
-
-        :param db: 数据库会话
-        :param menu_id: 菜单 ID
-        :return:
-        """
-        role_menu_stmt = delete(role_menu).where(role_menu.c.menu_id == menu_id)
-        await db.execute(role_menu_stmt)
-
-        return await self.delete_model(db, menu_id)
-
-    async def get_children(self, db: AsyncSession, menu_id: int) -> Sequence[Menu | None]:
-        """
-        获取子菜单列表
-
-        :param db: 数据库会话
-        :param menu_id: 菜单 ID
-        :return:
-        """
-        return await self.select_models(db, parent_id=menu_id)
-
-
-menu_dao: CRUDMenu = CRUDMenu(Menu)

backend/app/admin/crud/crud_opera_log.py

@@ -1,74 +0,0 @@
-from sqlalchemy import Select
-from sqlalchemy import delete as sa_delete
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy_crud_plus import CRUDPlus
-
-from backend.app.admin.model import OperaLog
-from backend.app.admin.schema.opera_log import CreateOperaLogParam
-
-
-class CRUDOperaLogDao(CRUDPlus[OperaLog]):
-    """操作日志数据库操作类"""
-
-    async def get_select(self, username: str | None, status: int | None, ip: str | None) -> Select:
-        """
-        获取操作日志列表查询表达式
-
-        :param username: 用户名
-        :param status: 操作状态
-        :param ip: IP 地址
-        :return:
-        """
-        filters = {}
-
-        if username is not None:
-            filters['username__like'] = f'%{username}%'
-        if status is not None:
-            filters['status__eq'] = status
-        if ip is not None:
-            filters['ip__like'] = f'%{ip}%'
-
-        return await self.select_order('created_time', 'desc', **filters)
-
-    async def create(self, db: AsyncSession, obj: CreateOperaLogParam) -> None:
-        """
-        创建操作日志
-
-        :param db: 数据库会话
-        :param obj: 操作日志创建参数
-        :return:
-        """
-        await self.create_model(db, obj)
-
-    async def bulk_create(self, db: AsyncSession, objs: list[CreateOperaLogParam]) -> None:
-        """
-        批量创建操作日志
-
-        :param db: 数据库会话
-        :param objs: 操作日志创建参数列表
-        :return:
-        """
-        await self.create_models(db, objs)
-
-    async def delete(self, db: AsyncSession, pks: list[int]) -> int:
-        """
-        批量删除操作日志
-
-        :param db: 数据库会话
-        :param pks: 操作日志 ID 列表
-        :return:
-        """
-        return await self.delete_model_by_column(db, allow_multiple=True, id__in=pks)
-
-    @staticmethod
-    async def delete_all(db: AsyncSession) -> None:
-        """
-        删除所有日志
-
-        :param db: 数据库会话
-        :return:
-        """
-        await db.execute(sa_delete(OperaLog))
-
-
-opera_log_dao: CRUDOperaLogDao = CRUDOperaLogDao(OperaLog)

backend/app/admin/crud/crud_role.py

@@ -1,178 +0,0 @@
-from collections.abc import Sequence
-from typing import Any
-
-from sqlalchemy import Select, delete, insert, select
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy_crud_plus import CRUDPlus, JoinConfig
-
-from backend.app.admin.model import DataScope, Menu, Role, role_data_scope, role_menu
-from backend.app.admin.schema.role import (
-    CreateRoleMenuParam,
-    CreateRoleParam,
-    CreateRoleScopeParam,
-    UpdateRoleMenuParam,
-    UpdateRoleParam,
-    UpdateRoleScopeParam,
-)
-from backend.utils.serializers import select_join_serialize
-
-
-class CRUDRole(CRUDPlus[Role]):
-    """角色数据库操作类"""
-
-    async def get(self, db: AsyncSession, role_id: int) -> Role | None:
-        """
-        获取角色详情
-
-        :param db: 数据库会话
-        :param role_id: 角色 ID
-        :return:
-        """
-        return await self.select_model(db, role_id)
-
-    @staticmethod
-    async def get_menus(db: AsyncSession, role_id: int) -> Sequence[Menu] | None:
-        """
-        获取角色菜单
-
-        :param db: 数据库会话
-        :param role_id: 角色 ID
-        :return:
-        """
-        menu_stmt = select(Menu).join(role_menu, Menu.id == role_menu.c.menu_id).where(role_menu.c.role_id == role_id)
-        result = await db.execute(menu_stmt)
-        return result.scalars().all()
-
-    async def get_join(self, db: AsyncSession, role_id: int) -> Any:
-        """
-        获取角色及关联数据
-
-        :param db: 数据库会话
-        :param role_id: 角色 ID
-        :return:
-        """
-        result = await self.select_models(
-            db,
-            id=role_id,
-            join_conditions=[
-                JoinConfig(model=role_menu, join_on=role_menu.c.role_id == self.model.id),
-                JoinConfig(model=Menu, join_on=Menu.id == role_menu.c.menu_id, fill_result=True),
-                JoinConfig(model=role_data_scope, join_on=role_data_scope.c.role_id == self.model.id),
-                JoinConfig(model=DataScope, join_on=DataScope.id == role_data_scope.c.data_scope_id, fill_result=True),
-            ],
-        )
-
-        return select_join_serialize(result, relationships=['Role-m2m-Menu', 'Role-m2m-DataScope:scopes'])
-
-    async def get_all(self, db: AsyncSession) -> Sequence[Role]:
-        """
-        获取所有角色
-
-        :param db: 数据库会话
-        :return:
-        """
-        return await self.select_models(db)
-
-    async def get_select(self, name: str | None, status: int | None) -> Select:
-        """
-        获取角色列表查询表达式
-
-        :param name: 角色名称
-        :param status: 角色状态
-        :return:
-        """
-
-        filters = {}
-
-        if name is not None:
-            filters['name__like'] = f'%{name}%'
-        if status is not None:
-            filters['status'] = status
-
-        return await self.select_order('id', **filters)
-
-    async def get_by_name(self, db: AsyncSession, name: str) -> Role | None:
-        """
-        通过名称获取角色
-
-        :param db: 数据库会话
-        :param name: 角色名称
-        :return:
-        """
-        return await self.select_model_by_column(db, name=name)
-
-    async def create(self, db: AsyncSession, obj: CreateRoleParam) -> None:
-        """
-        创建角色
-
-        :param db: 数据库会话
-        :param obj: 创建角色参数
-        :return:
-        """
-        await self.create_model(db, obj)
-
-    async def update(self, db: AsyncSession, role_id: int, obj: UpdateRoleParam) -> int:
-        """
-        更新角色
-
-        :param db: 数据库会话
-        :param role_id: 角色 ID
-        :param obj: 更新角色参数
-        :return:
-        """
-        return await self.update_model(db, role_id, obj)
-
-    @staticmethod
-    async def update_menus(db: AsyncSession, role_id: int, menu_ids: UpdateRoleMenuParam) -> int:
-        """
-        更新角色菜单
-
-        :param db: 数据库会话
-        :param role_id: 角色 ID
-        :param menu_ids: 菜单 ID 列表
-        :return:
-        """
-        role_menu_stmt = delete(role_menu).where(role_menu.c.role_id == role_id)
-        await db.execute(role_menu_stmt)
-
-        role_menu_data = [
-            CreateRoleMenuParam(role_id=role_id, menu_id=menu_id).model_dump() for menu_id in menu_ids.menus
-        ]
-        role_menu_stmt = insert(role_menu)
-        await db.execute(role_menu_stmt, role_menu_data)
-
-        return len(menu_ids.menus)
-
-    @staticmethod
-    async def update_scopes(db: AsyncSession, role_id: int, scope_ids: UpdateRoleScopeParam) -> int:
-        """
-        更新角色数据范围
-
-        :param db: 数据库会话
-        :param role_id: 角色 ID
-        :param scope_ids: 权限范围 ID 列表
-        :return:
-        """
-        role_scope_stmt = delete(role_data_scope).where(role_data_scope.c.role_id == role_id)
-        await db.execute(role_scope_stmt)
-
-        role_scope_data = [
-            CreateRoleScopeParam(role_id=role_id, data_scope_id=scope_id).model_dump() for scope_id in scope_ids.scopes
-        ]
-        role_scope_stmt = insert(role_data_scope)
-        await db.execute(role_scope_stmt, role_scope_data)
-
-        return len(scope_ids.scopes)
-
-    async def delete(self, db: AsyncSession, role_ids: list[int]) -> int:
-        """
-        批量删除角色
-
-        :param db: 数据库会话
-        :param role_ids: 角色 ID 列表
-        :return:
-        """
-        return await self.delete_model_by_column(db, allow_multiple=True, id__in=role_ids)
-
-
-role_dao: CRUDRole = CRUDRole(Role)

backend/app/admin/crud/crud_user.py

@@ -1,32 +1,14 @@
-from typing import Any
+from collections.abc import Sequence
 
 import bcrypt
 
-from sqlalchemy import Select, delete, insert, select
+from sqlalchemy import Select
 from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy_crud_plus import CRUDPlus, JoinConfig
+from sqlalchemy_crud_plus import CRUDPlus
 
-from backend.app.admin.model import (
+from backend.app.admin.model import User
-    DataRule,
+from backend.app.admin.schema.user import AddUserParam, UpdateUserParam
-    DataScope,
-    Dept,
-    Menu,
-    Role,
-    User,
-    data_scope_rule,
-    role_data_scope,
-    role_menu,
-    user_role,
-)
-from backend.app.admin.schema.user import (
-    AddOAuth2UserParam,
-    AddUserParam,
-    AddUserRoleParam,
-    UpdateUserParam,
-)
 from backend.app.admin.utils.password_security import get_hash_password
-from backend.plugin.oauth2.crud.crud_user_social import user_social_dao
-from backend.utils.serializers import select_join_serialize
 from backend.utils.timezone import timezone
 
 
@@ -41,7 +23,7 @@ class CRUDUser(CRUDPlus[User]):
         :param user_id: 用户 ID
         :return:
         """
-        return await self.select_model(db, user_id)
+        return await self.select_model(db, user_id, deleted=0)
 
     async def get_by_username(self, db: AsyncSession, username: str) -> User | None:
         """
@@ -51,7 +33,17 @@ class CRUDUser(CRUDPlus[User]):
         :param username: 用户名
         :return:
         """
-        return await self.select_model_by_column(db, username=username)
+        return await self.select_model_by_column(db, username=username, deleted=0)
+
+    async def get_all_by_usernames(self, db: AsyncSession, usernames: list[str]) -> Sequence[User]:
+        """
+        通过用户名列表批量获取用户
+
+        :param db: 数据库会话
+        :param usernames: 用户名列表
+        :return:
+        """
+        return await self.select_models(db, username__in=usernames, deleted=0)
 
     async def get_by_nickname(self, db: AsyncSession, nickname: str) -> User | None:
         """
@@ -61,7 +53,7 @@ class CRUDUser(CRUDPlus[User]):
         :param nickname: 用户昵称
         :return:
         """
-        return await self.select_model_by_column(db, nickname=nickname)
+        return await self.select_model_by_column(db, nickname=nickname, deleted=0)
 
     async def check_email(self, db: AsyncSession, email: str) -> User | None:
         """
@@ -71,22 +63,19 @@ class CRUDUser(CRUDPlus[User]):
         :param email: 电子邮箱
         :return:
         """
-        return await self.select_model_by_column(db, email=email)
+        return await self.select_model_by_column(db, email=email, deleted=0)
 
-    async def get_select(self, dept: int | None, username: str | None, phone: str | None, status: int | None) -> Select:
+    async def get_select(self, username: str | None, phone: str | None, status: int | None) -> Select:
         """
         获取用户列表查询表达式
 
-        :param dept: 部门 ID
         :param username: 用户名
         :param phone: 电话号码
         :param status: 用户状态
         :return:
         """
-        filters = {}
+        filters = {'deleted': 0}
 
-        if dept:
-            filters['dept_id'] = dept
         if username:
             filters['username__like'] = f'%{username}%'
         if phone:
@@ -94,16 +83,7 @@ class CRUDUser(CRUDPlus[User]):
         if status is not None:
             filters['status'] = status
 
-        return await self.select_order(
+        return await self.select_order('id', 'desc', **filters)
-            'id',
-            'desc',
-            join_conditions=[
-                JoinConfig(model=Dept, join_on=Dept.id == self.model.dept_id, fill_result=True),
-                JoinConfig(model=user_role, join_on=user_role.c.user_id == self.model.id),
-                JoinConfig(model=Role, join_on=Role.id == user_role.c.role_id, fill_result=True),
-            ],
-            **filters,
-        )
 
     async def add(self, db: AsyncSession, obj: AddUserParam) -> None:
         """
@@ -116,41 +96,12 @@ class CRUDUser(CRUDPlus[User]):
         salt = bcrypt.gensalt()
         obj.password = get_hash_password(obj.password, salt)
 
-        dict_obj = obj.model_dump(exclude={'roles'})
+        dict_obj = obj.model_dump()
         dict_obj.update({'salt': salt})
         new_user = self.model(**dict_obj)
         db.add(new_user)
         await db.flush()
 
-        role_stmt = select(Role).where(Role.id.in_(obj.roles))
-        result = await db.execute(role_stmt)
-        roles = result.scalars().all()
-
-        user_role_data = [AddUserRoleParam(user_id=new_user.id, role_id=role.id).model_dump() for role in roles]
-        user_role_stmt = insert(user_role)
-        await db.execute(user_role_stmt, user_role_data)
-
-    async def add_by_oauth2(self, db: AsyncSession, obj: AddOAuth2UserParam) -> None:
-        """
-        通过 OAuth2 添加用户
-
-        :param db: 数据库会话
-        :param obj: 注册用户参数
-        :return:
-        """
-        dict_obj = obj.model_dump()
-        dict_obj.update({'is_staff': True, 'salt': None})
-        new_user = self.model(**dict_obj)
-        db.add(new_user)
-        await db.flush()
-
-        role_stmt = select(Role)
-        result = await db.execute(role_stmt)
-        role = result.scalars().first()  # 默认绑定第一个角色
-
-        user_role_stmt = insert(user_role).values(AddUserRoleParam(user_id=new_user.id, role_id=role.id).model_dump())
-        await db.execute(user_role_stmt)
-
     async def update(self, db: AsyncSession, user_id: int, obj: UpdateUserParam) -> int:
         """
         更新用户信息
@@ -160,22 +111,7 @@ class CRUDUser(CRUDPlus[User]):
         :param obj: 更新用户参数
         :return:
         """
-        role_ids = obj.roles
+        count = await self.update_model_by_column(db, obj, id=user_id, deleted=0)
-        del obj.roles
-
-        count = await self.update_model(db, user_id, obj)
-
-        role_stmt = select(Role).where(Role.id.in_(role_ids))
-        result = await db.execute(role_stmt)
-        roles = result.scalars().all()
-
-        user_role_stmt = delete(user_role).where(user_role.c.user_id == user_id)
-        await db.execute(user_role_stmt)
-
-        user_role_data = [AddUserRoleParam(user_id=user_id, role_id=role.id).model_dump() for role in roles]
-        user_role_stmt = insert(user_role)
-        await db.execute(user_role_stmt, user_role_data)
-
         return count
 
     async def update_login_time(self, db: AsyncSession, username: str) -> int:
@@ -186,7 +122,7 @@ class CRUDUser(CRUDPlus[User]):
         :param username: 用户名
         :return:
         """
-        return await self.update_model_by_column(db, {'last_login_time': timezone.now()}, username=username)
+        return await self.update_model_by_column(db, {'last_login_time': timezone.now()}, username=username, deleted=0)
 
     async def update_password_changed_time(self, db: AsyncSession, user_id: int) -> int:
         """
@@ -196,7 +132,9 @@ class CRUDUser(CRUDPlus[User]):
         :param user_id: 用户 ID
         :return:
         """
-        return await self.update_model(db, user_id, {'last_password_changed_time': timezone.now()})
+        return await self.update_model_by_column(
+            db, {'last_password_changed_time': timezone.now()}, id=user_id, deleted=0
+        )
 
     async def update_nickname(self, db: AsyncSession, user_id: int, nickname: str) -> int:
         """
@@ -207,7 +145,7 @@ class CRUDUser(CRUDPlus[User]):
         :param nickname: 用户昵称
         :return:
         """
-        return await self.update_model(db, user_id, {'nickname': nickname})
+        return await self.update_model_by_column(db, {'nickname': nickname}, id=user_id, deleted=0)
 
     async def update_avatar(self, db: AsyncSession, user_id: int, avatar: str) -> int:
         """
@@ -218,7 +156,7 @@ class CRUDUser(CRUDPlus[User]):
         :param avatar: 头像地址
         :return:
         """
-        return await self.update_model(db, user_id, {'avatar': avatar})
+        return await self.update_model_by_column(db, {'avatar': avatar}, id=user_id, deleted=0)
 
     async def update_email(self, db: AsyncSession, user_id: int, email: str) -> int:
         """
@@ -229,7 +167,7 @@ class CRUDUser(CRUDPlus[User]):
         :param email: 邮箱
         :return:
         """
-        return await self.update_model(db, user_id, {'email': email})
+        return await self.update_model_by_column(db, {'email': email}, id=user_id, deleted=0)
 
     async def reset_password(self, db: AsyncSession, pk: int, password: str) -> int:
         """
@@ -242,7 +180,7 @@ class CRUDUser(CRUDPlus[User]):
         """
         salt = bcrypt.gensalt()
         new_pwd = get_hash_password(password, salt)
-        return await self.update_model(db, pk, {'password': new_pwd, 'salt': salt}, flush=True)
+        return await self.update_model_by_column(db, {'password': new_pwd, 'salt': salt}, flush=True, id=pk, deleted=0)
 
     async def set_super(self, db: AsyncSession, user_id: int, *, is_super: bool) -> int:
         """
@@ -253,7 +191,7 @@ class CRUDUser(CRUDPlus[User]):
         :param is_super: 是否超级管理员
         :return:
         """
-        return await self.update_model(db, user_id, {'is_superuser': is_super})
+        return await self.update_model_by_column(db, {'is_superuser': is_super}, id=user_id, deleted=0)
 
     async def set_staff(self, db: AsyncSession, user_id: int, *, is_staff: bool) -> int:
         """
@@ -264,7 +202,7 @@ class CRUDUser(CRUDPlus[User]):
         :param is_staff: 是否可登录后台
         :return:
         """
-        return await self.update_model(db, user_id, {'is_staff': is_staff})
+        return await self.update_model_by_column(db, {'is_staff': is_staff}, id=user_id, deleted=0)
 
     async def set_status(self, db: AsyncSession, user_id: int, status: int) -> int:
         """
@@ -275,7 +213,7 @@ class CRUDUser(CRUDPlus[User]):
         :param status: 状态
         :return:
         """
-        return await self.update_model(db, user_id, {'status': status})
+        return await self.update_model_by_column(db, {'status': status}, id=user_id, deleted=0)
 
     async def set_multi_login(self, db: AsyncSession, user_id: int, *, multi_login: bool) -> int:
         """
@@ -286,7 +224,7 @@ class CRUDUser(CRUDPlus[User]):
         :param multi_login: 是否允许多端登录
         :return:
         """
-        return await self.update_model(db, user_id, {'is_multi_login': multi_login})
+        return await self.update_model_by_column(db, {'is_multi_login': multi_login}, id=user_id, deleted=0)
 
     async def delete(self, db: AsyncSession, user_id: int) -> int:
         """
@@ -296,60 +234,15 @@ class CRUDUser(CRUDPlus[User]):
         :param user_id: 用户 ID
         :return:
         """
-        user_role_stmt = delete(user_role).where(user_role.c.user_id == user_id)
+        return await self.delete_model_by_column(
-        await db.execute(user_role_stmt)
-
-        await user_social_dao.delete_by_user_id(db, user_id)
-
-        return await self.delete_model(db, user_id)
-
-    async def get_join(
-        self,
-        db: AsyncSession,
-        *,
-        user_id: int | None = None,
-        username: str | None = None,
-    ) -> Any | None:
-        """
-        获取用户关联信息
-
-        :param db: 数据库会话
-        :param user_id: 用户 ID
-        :param username: 用户名
-        :return:
-        """
-        filters = {}
-
-        if user_id:
-            filters['id'] = user_id
-        if username:
-            filters['username'] = username
-
-        result = await self.select_models(
             db,
-            join_conditions=[
+            logical_deletion=True,
-                JoinConfig(model=Dept, join_on=Dept.id == self.model.dept_id, fill_result=True),
+            deleted_flag_column='deleted',
-                JoinConfig(model=user_role, join_on=user_role.c.user_id == self.model.id),
+            deleted_flag_value=self.model.id,
-                JoinConfig(model=Role, join_on=Role.id == user_role.c.role_id, fill_result=True),
+            deleted_at_column='deleted_time',
-                JoinConfig(model=role_menu, join_on=role_menu.c.role_id == Role.id),
+            deleted_at_factory=timezone.now(),
-                JoinConfig(model=Menu, join_on=Menu.id == role_menu.c.menu_id, fill_result=True),
+            id=user_id,
-                JoinConfig(model=role_data_scope, join_on=role_data_scope.c.role_id == Role.id),
+            deleted=0,
-                JoinConfig(model=DataScope, join_on=DataScope.id == role_data_scope.c.data_scope_id, fill_result=True),
-                JoinConfig(model=data_scope_rule, join_on=data_scope_rule.c.data_scope_id == DataScope.id),
-                JoinConfig(model=DataRule, join_on=DataRule.id == data_scope_rule.c.data_rule_id, fill_result=True),
-            ],
-            **filters,
-        )
-
-        return select_join_serialize(
-            result,
-            relationships=[
-                'User-m2o-Dept',
-                'User-m2m-Role',
-                'Role-m2m-Menu',
-                'Role-m2m-DataScope:scopes',
-                'DataScope-m2m-DataRule:rules',
-            ],
         )
 
 

backend/app/admin/model/__init__.py

@@ -1,13 +1,2 @@
-from backend.app.admin.model.data_rule import DataRule as DataRule
-from backend.app.admin.model.data_scope import DataScope as DataScope
-from backend.app.admin.model.dept import Dept as Dept
-from backend.app.admin.model.login_log import LoginLog as LoginLog
-from backend.app.admin.model.m2m import data_scope_rule as data_scope_rule
-from backend.app.admin.model.m2m import role_data_scope as role_data_scope
-from backend.app.admin.model.m2m import role_menu as role_menu
-from backend.app.admin.model.m2m import user_role as user_role
-from backend.app.admin.model.menu import Menu as Menu
-from backend.app.admin.model.opera_log import OperaLog as OperaLog
-from backend.app.admin.model.role import Role as Role
 from backend.app.admin.model.user import User as User
 from backend.app.admin.model.user_password_history import UserPasswordHistory as UserPasswordHistory

backend/app/admin/model/data_rule.py

@@ -1,21 +0,0 @@
-import sqlalchemy as sa
-
-from sqlalchemy.orm import Mapped, mapped_column
-
-from backend.common.model import Base, id_key
-
-
-class DataRule(Base):
-    """数据规则表"""
-
-    __tablename__ = 'sys_data_rule'
-
-    id: Mapped[id_key] = mapped_column(init=False)
-    name: Mapped[str] = mapped_column(sa.String(512), unique=True, comment='名称')
-    model: Mapped[str] = mapped_column(sa.String(64), comment='模型名称')
-    column: Mapped[str] = mapped_column(sa.String(32), comment='模型字段名')
-    operator: Mapped[int] = mapped_column(comment='运算符（0：and、1：or）')
-    expression: Mapped[int] = mapped_column(
-        comment='表达式（0：==、1：!=、2：>、3：>=、4：<、5：<=、6：in、7：not_in）',
-    )
-    value: Mapped[str] = mapped_column(sa.String(256), comment='规则值')

backend/app/admin/model/data_scope.py

@@ -1,15 +0,0 @@
-import sqlalchemy as sa
-
-from sqlalchemy.orm import Mapped, mapped_column
-
-from backend.common.model import Base, id_key
-
-
-class DataScope(Base):
-    """数据范围表"""
-
-    __tablename__ = 'sys_data_scope'
-
-    id: Mapped[id_key] = mapped_column(init=False)
-    name: Mapped[str] = mapped_column(sa.String(64), unique=True, comment='名称')
-    status: Mapped[int] = mapped_column(default=1, comment='状态（0停用 1正常）')

backend/app/admin/model/dept.py

@@ -1,23 +0,0 @@
-import sqlalchemy as sa
-
-from sqlalchemy.orm import Mapped, mapped_column
-
-from backend.common.model import Base, id_key
-
-
-class Dept(Base):
-    """部门表"""
-
-    __tablename__ = 'sys_dept'
-
-    id: Mapped[id_key] = mapped_column(init=False)
-    name: Mapped[str] = mapped_column(sa.String(64), comment='部门名称')
-    sort: Mapped[int] = mapped_column(default=0, comment='排序')
-    leader: Mapped[str | None] = mapped_column(sa.String(32), default=None, comment='负责人')
-    phone: Mapped[str | None] = mapped_column(sa.String(11), default=None, comment='手机')
-    email: Mapped[str | None] = mapped_column(sa.String(64), default=None, comment='邮箱')
-    status: Mapped[int] = mapped_column(default=1, comment='部门状态(0停用 1正常)')
-    del_flag: Mapped[bool] = mapped_column(default=False, comment='删除标志（0删除 1存在）')
-
-    # 父级部门
-    parent_id: Mapped[int | None] = mapped_column(sa.BigInteger, default=None, index=True, comment='父部门ID')

backend/app/admin/model/login_log.py

@@ -1,35 +0,0 @@
-from datetime import datetime
-
-import sqlalchemy as sa
-
-from sqlalchemy.orm import Mapped, mapped_column
-
-from backend.common.model import DataClassBase, TimeZone, UniversalText, id_key
-from backend.utils.timezone import timezone
-
-
-class LoginLog(DataClassBase):
-    """登录日志表"""
-
-    __tablename__ = 'sys_login_log'
-
-    id: Mapped[id_key] = mapped_column(init=False)
-    user_uuid: Mapped[str] = mapped_column(sa.String(64), comment='用户UUID')
-    username: Mapped[str] = mapped_column(sa.String(64), comment='用户名')
-    status: Mapped[int] = mapped_column(insert_default=0, comment='登录状态(0失败 1成功)')
-    ip: Mapped[str] = mapped_column(sa.String(64), comment='登录IP地址')
-    country: Mapped[str | None] = mapped_column(sa.String(64), comment='国家')
-    region: Mapped[str | None] = mapped_column(sa.String(64), comment='地区')
-    city: Mapped[str | None] = mapped_column(sa.String(64), comment='城市')
-    user_agent: Mapped[str] = mapped_column(sa.String(256), comment='请求头')
-    os: Mapped[str | None] = mapped_column(sa.String(64), comment='操作系统')
-    browser: Mapped[str | None] = mapped_column(sa.String(64), comment='浏览器')
-    device: Mapped[str | None] = mapped_column(sa.String(64), comment='设备')
-    msg: Mapped[str] = mapped_column(UniversalText, comment='提示消息')
-    login_time: Mapped[datetime] = mapped_column(TimeZone, comment='登录时间')
-    created_time: Mapped[datetime] = mapped_column(
-        TimeZone,
-        init=False,
-        default_factory=timezone.now,
-        comment='创建时间',
-    )

backend/app/admin/model/m2m.py

@@ -1,39 +0,0 @@
-import sqlalchemy as sa
-
-from backend.common.model import MappedBase
-
-# 用户角色表
-user_role = sa.Table(
-    'sys_user_role',
-    MappedBase.metadata,
-    sa.Column('id', sa.BigInteger, primary_key=True, unique=True, index=True, autoincrement=True, comment='主键ID'),
-    sa.Column('user_id', sa.BigInteger, primary_key=True, comment='用户ID'),
-    sa.Column('role_id', sa.BigInteger, primary_key=True, comment='角色ID'),
-)
-
-# 角色菜单表
-role_menu = sa.Table(
-    'sys_role_menu',
-    MappedBase.metadata,
-    sa.Column('id', sa.BigInteger, primary_key=True, unique=True, index=True, autoincrement=True, comment='主键ID'),
-    sa.Column('role_id', sa.BigInteger, primary_key=True, comment='角色ID'),
-    sa.Column('menu_id', sa.BigInteger, primary_key=True, comment='菜单ID'),
-)
-
-# 角色数据范围表
-role_data_scope = sa.Table(
-    'sys_role_data_scope',
-    MappedBase.metadata,
-    sa.Column('id', sa.BigInteger, primary_key=True, unique=True, index=True, autoincrement=True, comment='主键 ID'),
-    sa.Column('role_id', sa.BigInteger, primary_key=True, comment='角色 ID'),
-    sa.Column('data_scope_id', sa.BigInteger, primary_key=True, comment='数据范围 ID'),
-)
-
-# 数据范围规则表
-data_scope_rule = sa.Table(
-    'sys_data_scope_rule',
-    MappedBase.metadata,
-    sa.Column('id', sa.BigInteger, primary_key=True, unique=True, index=True, autoincrement=True, comment='主键ID'),
-    sa.Column('data_scope_id', sa.BigInteger, primary_key=True, comment='数据范围 ID'),
-    sa.Column('data_rule_id', sa.BigInteger, primary_key=True, comment='数据规则 ID'),
-)

backend/app/admin/model/menu.py

@@ -1,29 +0,0 @@
-import sqlalchemy as sa
-
-from sqlalchemy.orm import Mapped, mapped_column
-
-from backend.common.model import Base, UniversalText, id_key
-
-
-class Menu(Base):
-    """菜单表"""
-
-    __tablename__ = 'sys_menu'
-
-    id: Mapped[id_key] = mapped_column(init=False)
-    title: Mapped[str] = mapped_column(sa.String(64), comment='菜单标题')
-    name: Mapped[str] = mapped_column(sa.String(64), comment='菜单名称')
-    path: Mapped[str | None] = mapped_column(sa.String(200), comment='路由地址')
-    sort: Mapped[int] = mapped_column(default=0, comment='排序')
-    icon: Mapped[str | None] = mapped_column(sa.String(128), default=None, comment='菜单图标')
-    type: Mapped[int] = mapped_column(default=0, comment='菜单类型（0目录 1菜单 2按钮 3内嵌 4外链）')
-    component: Mapped[str | None] = mapped_column(sa.String(256), default=None, comment='组件路径')
-    perms: Mapped[str | None] = mapped_column(sa.String(128), default=None, comment='权限标识')
-    status: Mapped[int] = mapped_column(default=1, comment='菜单状态（0停用 1正常）')
-    display: Mapped[int] = mapped_column(default=1, comment='是否显示（0否 1是）')
-    cache: Mapped[int] = mapped_column(default=1, comment='是否缓存（0否 1是）')
-    link: Mapped[str | None] = mapped_column(UniversalText, default=None, comment='外链地址')
-    remark: Mapped[str | None] = mapped_column(UniversalText, default=None, comment='备注')
-
-    # 父级菜单
-    parent_id: Mapped[int | None] = mapped_column(sa.BigInteger, default=None, index=True, comment='父菜单ID')

backend/app/admin/model/opera_log.py

@@ -1,38 +0,0 @@
-from datetime import datetime
-
-import sqlalchemy as sa
-
-from sqlalchemy.orm import Mapped, mapped_column
-
-from backend.common.model import DataClassBase, TimeZone, UniversalText, id_key
-from backend.utils.timezone import timezone
-
-
-class OperaLog(DataClassBase):
-    """操作日志表"""
-
-    __tablename__ = 'sys_opera_log'
-
-    id: Mapped[id_key] = mapped_column(init=False)
-    trace_id: Mapped[str] = mapped_column(sa.String(32), comment='请求跟踪 ID')
-    username: Mapped[str | None] = mapped_column(sa.String(64), comment='用户名')
-    method: Mapped[str] = mapped_column(sa.String(32), comment='请求类型')
-    title: Mapped[str] = mapped_column(sa.String(256), comment='操作模块')
-    path: Mapped[str] = mapped_column(sa.String(512), comment='请求路径')
-    ip: Mapped[str] = mapped_column(sa.String(64), comment='IP地址')
-    country: Mapped[str | None] = mapped_column(sa.String(64), comment='国家')
-    region: Mapped[str | None] = mapped_column(sa.String(64), comment='地区')
-    city: Mapped[str | None] = mapped_column(sa.String(64), comment='城市')
-    user_agent: Mapped[str] = mapped_column(sa.String(512), comment='请求头')
-    os: Mapped[str | None] = mapped_column(sa.String(64), comment='操作系统')
-    browser: Mapped[str | None] = mapped_column(sa.String(64), comment='浏览器')
-    device: Mapped[str | None] = mapped_column(sa.String(64), comment='设备')
-    args: Mapped[str | None] = mapped_column(sa.JSON(), comment='请求参数')
-    status: Mapped[int] = mapped_column(comment='操作状态（0异常 1正常）')
-    code: Mapped[str] = mapped_column(sa.String(32), insert_default='200', comment='操作状态码')
-    msg: Mapped[str | None] = mapped_column(UniversalText, comment='提示消息')
-    cost_time: Mapped[float] = mapped_column(insert_default=0.0, comment='请求耗时（ms）')
-    opera_time: Mapped[datetime] = mapped_column(TimeZone, comment='操作时间')
-    created_time: Mapped[datetime] = mapped_column(
-        TimeZone, init=False, default_factory=timezone.now, comment='创建时间'
-    )

backend/app/admin/model/role.py

@@ -1,17 +0,0 @@
-import sqlalchemy as sa
-
-from sqlalchemy.orm import Mapped, mapped_column
-
-from backend.common.model import Base, UniversalText, id_key
-
-
-class Role(Base):
-    """角色表"""
-
-    __tablename__ = 'sys_role'
-
-    id: Mapped[id_key] = mapped_column(init=False)
-    name: Mapped[str] = mapped_column(sa.String(32), unique=True, comment='角色名称')
-    status: Mapped[int] = mapped_column(default=1, comment='角色状态（0停用 1正常）')
-    is_filter_scopes: Mapped[bool] = mapped_column(default=True, comment='过滤数据权限(0否 1是)')
-    remark: Mapped[str | None] = mapped_column(UniversalText, default=None, comment='备注')

backend/app/admin/model/user.py

@@ -13,14 +13,19 @@ class User(Base):
     """用户表"""
 
     __tablename__ = 'sys_user'
+    __table_args__ = (
+        sa.UniqueConstraint('username', 'deleted', name='uk_sys_user_username_deleted'),
+        sa.UniqueConstraint('email', 'deleted', name='uk_sys_user_email_deleted'),
+        {'comment': '用户表'},
+    )
 
     id: Mapped[id_key] = mapped_column(init=False)
     uuid: Mapped[str] = mapped_column(sa.String(64), init=False, default_factory=uuid4_str, unique=True)
-    username: Mapped[str] = mapped_column(sa.String(64), unique=True, index=True, comment='用户名')
+    username: Mapped[str] = mapped_column(sa.String(64), index=True, comment='用户名')
     nickname: Mapped[str] = mapped_column(sa.String(64), comment='昵称')
     password: Mapped[str | None] = mapped_column(sa.String(256), comment='密码')
-    salt: Mapped[bytes | None] = mapped_column(sa.LargeBinary(255), comment='加密盐')
+    salt: Mapped[bytes | None] = mapped_column(sa.LargeBinary(256), comment='加密盐')
-    email: Mapped[str | None] = mapped_column(sa.String(256), default=None, unique=True, index=True, comment='邮箱')
+    email: Mapped[str | None] = mapped_column(sa.String(256), default=None, index=True, comment='邮箱')
     phone: Mapped[str | None] = mapped_column(sa.String(11), default=None, comment='手机号')
     avatar: Mapped[str | None] = mapped_column(sa.String(256), default=None, comment='头像')
     status: Mapped[int] = mapped_column(default=1, index=True, comment='用户账号状态(0停用 1正常)')
@@ -34,6 +39,3 @@ class User(Base):
     last_password_changed_time: Mapped[datetime | None] = mapped_column(
         TimeZone, init=False, default_factory=timezone.now, comment='上次密码变更时间'
     )
-
-    # 逻辑外键
-    dept_id: Mapped[int | None] = mapped_column(sa.BigInteger, default=None, comment='部门关联ID')

backend/app/admin/schema/data_rule.py

@@ -1,48 +0,0 @@
-from datetime import datetime
-
-from pydantic import ConfigDict, Field
-
-from backend.common.enums import RoleDataRuleExpressionType, RoleDataRuleOperatorType
-from backend.common.schema import SchemaBase
-
-
-class DataRuleSchemaBase(SchemaBase):
-    """数据规则基础模型"""
-
-    name: str = Field(description='规则名称')
-    model: str = Field(description='模型名称')
-    column: str = Field(description='字段名称')
-    operator: RoleDataRuleOperatorType = Field(description='操作符（AND/OR）')
-    expression: RoleDataRuleExpressionType = Field(description='表达式类型')
-    value: str = Field(description='规则值')
-
-
-class CreateDataRuleParam(DataRuleSchemaBase):
-    """创建数据规则参数"""
-
-
-class UpdateDataRuleParam(DataRuleSchemaBase):
-    """更新数据规则参数"""
-
-
-class DeleteDataRuleParam(SchemaBase):
-    """删除数据规则参数"""
-
-    pks: list[int] = Field(description='规则 ID 列表')
-
-
-class GetDataRuleDetail(DataRuleSchemaBase):
-    """数据规则详情"""
-
-    model_config = ConfigDict(from_attributes=True, frozen=True)
-
-    id: int = Field(description='规则 ID')
-    created_time: datetime = Field(description='创建时间')
-    updated_time: datetime | None = Field(None, description='更新时间')
-
-
-class GetDataRuleColumnDetail(SchemaBase):
-    """数据规则可用模型字段详情"""
-
-    key: str = Field(description='字段名')
-    comment: str = Field(description='字段评论')

backend/app/admin/schema/data_scope.py

@@ -1,57 +0,0 @@
-from datetime import datetime
-
-from pydantic import ConfigDict, Field
-
-from backend.app.admin.schema.data_rule import GetDataRuleDetail
-from backend.common.enums import StatusType
-from backend.common.schema import SchemaBase
-
-
-class DataScopeBase(SchemaBase):
-    """数据范围基础模型"""
-
-    name: str = Field(description='名称')
-    status: StatusType = Field(description='状态')
-
-
-class CreateDataScopeParam(DataScopeBase):
-    """创建数据范围参数"""
-
-
-class UpdateDataScopeParam(DataScopeBase):
-    """更新数据范围参数"""
-
-
-class CreateDataScopeRuleParam(SchemaBase):
-    """创建数据范围规则参数"""
-
-    data_scope_id: int = Field(description='数据范围 ID')
-    data_rule_id: int = Field(description='数据规则 ID')
-
-
-class UpdateDataScopeRuleParam(SchemaBase):
-    """更新数据范围规则参数"""
-
-    rules: list[int] = Field(description='数据规则 ID 列表')
-
-
-class DeleteDataScopeParam(SchemaBase):
-    """删除数据范围参数"""
-
-    pks: list[int] = Field(description='数据范围 ID 列表')
-
-
-class GetDataScopeDetail(DataScopeBase):
-    """数据范围详情"""
-
-    model_config = ConfigDict(from_attributes=True)
-
-    id: int = Field(description='数据范围 ID')
-    created_time: datetime = Field(description='创建时间')
-    updated_time: datetime | None = Field(None, description='更新时间')
-
-
-class GetDataScopeWithRelationDetail(GetDataScopeDetail):
-    """数据范围关联详情"""
-
-    rules: list[GetDataRuleDetail | None] = Field([], description='数据规则列表')

backend/app/admin/schema/dept.py

@@ -1,43 +0,0 @@
-from datetime import datetime
-
-from pydantic import ConfigDict, Field
-
-from backend.common.enums import StatusType
-from backend.common.schema import CustomEmailStr, CustomPhoneNumber, SchemaBase
-
-
-class DeptSchemaBase(SchemaBase):
-    """部门基础模型"""
-
-    name: str = Field(description='部门名称')
-    parent_id: int | None = Field(None, description='部门父级 ID')
-    sort: int = Field(0, ge=0, description='排序')
-    leader: str | None = Field(None, description='负责人')
-    phone: CustomPhoneNumber | None = Field(None, description='联系电话')
-    email: CustomEmailStr | None = Field(None, description='邮箱')
-    status: StatusType = Field(description='状态')
-
-
-class CreateDeptParam(DeptSchemaBase):
-    """创建部门参数"""
-
-
-class UpdateDeptParam(DeptSchemaBase):
-    """更新部门参数"""
-
-
-class GetDeptDetail(DeptSchemaBase):
-    """部门详情"""
-
-    model_config = ConfigDict(from_attributes=True)
-
-    id: int = Field(description='部门 ID')
-    del_flag: bool = Field(description='是否删除')
-    created_time: datetime = Field(description='创建时间')
-    updated_time: datetime | None = Field(None, description='更新时间')
-
-
-class GetDeptTree(GetDeptDetail):
-    """获取部门树"""
-
-    children: list['GetDeptTree'] | None = Field(None, description='子菜单')

backend/app/admin/schema/login_log.py

@@ -1,46 +0,0 @@
-from datetime import datetime
-
-from pydantic import ConfigDict, Field
-
-from backend.common.schema import SchemaBase
-
-
-class LoginLogSchemaBase(SchemaBase):
-    """登录日志基础模型"""
-
-    user_uuid: str = Field(description='用户 UUID')
-    username: str = Field(description='用户名')
-    status: int = Field(description='登录状态')
-    ip: str = Field(description='IP 地址')
-    country: str | None = Field(None, description='国家')
-    region: str | None = Field(None, description='地区')
-    city: str | None = Field(None, description='城市')
-    user_agent: str = Field(description='用户代理')
-    browser: str | None = Field(None, description='浏览器')
-    os: str | None = Field(None, description='操作系统')
-    device: str | None = Field(None, description='设备')
-    msg: str = Field(description='消息')
-    login_time: datetime = Field(description='登录时间')
-
-
-class CreateLoginLogParam(LoginLogSchemaBase):
-    """创建登录日志参数"""
-
-
-class UpdateLoginLogParam(LoginLogSchemaBase):
-    """更新登录日志参数"""
-
-
-class DeleteLoginLogParam(SchemaBase):
-    """删除登录日志参数"""
-
-    pks: list[int] = Field(description='登录日志 ID 列表')
-
-
-class GetLoginLogDetail(LoginLogSchemaBase):
-    """登录日志详情"""
-
-    model_config = ConfigDict(from_attributes=True)
-
-    id: int = Field(description='日志 ID')
-    created_time: datetime = Field(description='创建时间')

backend/app/admin/schema/menu.py

@@ -1,49 +0,0 @@
-from datetime import datetime
-
-from pydantic import ConfigDict, Field
-
-from backend.common.enums import MenuType, StatusType
-from backend.common.schema import SchemaBase
-
-
-class MenuSchemaBase(SchemaBase):
-    """菜单基础模型"""
-
-    title: str = Field(description='菜单标题')
-    name: str = Field(description='菜单名称')
-    path: str | None = Field(None, description='路由地址')
-    parent_id: int | None = Field(None, description='菜单父级 ID')
-    sort: int = Field(0, ge=0, description='排序')
-    icon: str | None = Field(None, description='图标')
-    type: MenuType = Field(description='菜单类型（0目录 1菜单 2按钮 3内嵌 4外链）')
-    component: str | None = Field(None, description='组件路径')
-    perms: str | None = Field(None, description='权限标识')
-    status: StatusType = Field(description='状态')
-    display: StatusType = Field(description='是否显示')
-    cache: StatusType = Field(description='是否缓存')
-    link: str | None = Field(None, description='外链地址')
-    remark: str | None = Field(None, description='备注')
-
-
-class CreateMenuParam(MenuSchemaBase):
-    """创建菜单参数"""
-
-
-class UpdateMenuParam(MenuSchemaBase):
-    """更新菜单参数"""
-
-
-class GetMenuDetail(MenuSchemaBase):
-    """菜单详情"""
-
-    model_config = ConfigDict(from_attributes=True)
-
-    id: int = Field(description='菜单 ID')
-    created_time: datetime = Field(description='创建时间')
-    updated_time: datetime | None = Field(None, description='更新时间')
-
-
-class GetMenuTree(GetMenuDetail):
-    """获取菜单树"""
-
-    children: list['GetMenuTree'] | None = Field(None, description='子菜单')

backend/app/admin/schema/opera_log.py

@@ -1,54 +0,0 @@
-from datetime import datetime
-from typing import Any
-
-from pydantic import ConfigDict, Field
-
-from backend.common.enums import StatusType
-from backend.common.schema import SchemaBase
-
-
-class OperaLogSchemaBase(SchemaBase):
-    """操作日志基础模型"""
-
-    trace_id: str = Field(description='追踪 ID')
-    username: str | None = Field(None, description='用户名')
-    method: str = Field(description='请求方法')
-    title: str = Field(description='操作标题')
-    path: str = Field(description='请求路径')
-    ip: str = Field(description='IP 地址')
-    country: str | None = Field(None, description='国家')
-    region: str | None = Field(None, description='地区')
-    city: str | None = Field(None, description='城市')
-    user_agent: str = Field(description='用户代理')
-    os: str | None = Field(None, description='操作系统')
-    browser: str | None = Field(None, description='浏览器')
-    device: str | None = Field(None, description='设备')
-    args: dict[str, Any] | None = Field(None, description='请求参数')
-    status: StatusType = Field(description='状态')
-    code: str = Field(description='状态码')
-    msg: str | None = Field(None, description='消息')
-    cost_time: float = Field(description='耗时')
-    opera_time: datetime = Field(description='操作时间')
-
-
-class CreateOperaLogParam(OperaLogSchemaBase):
-    """创建操作日志参数"""
-
-
-class UpdateOperaLogParam(OperaLogSchemaBase):
-    """更新操作日志参数"""
-
-
-class DeleteOperaLogParam(SchemaBase):
-    """删除操作日志参数"""
-
-    pks: list[int] = Field(description='操作日志 ID 列表')
-
-
-class GetOperaLogDetail(OperaLogSchemaBase):
-    """操作日志详情"""
-
-    model_config = ConfigDict(from_attributes=True)
-
-    id: int = Field(description='日志 ID')
-    created_time: datetime = Field(description='创建时间')

backend/app/admin/schema/role.py

@@ -1,74 +0,0 @@
-from datetime import datetime
-
-from pydantic import ConfigDict, Field
-
-from backend.app.admin.schema.data_scope import GetDataScopeWithRelationDetail
-from backend.app.admin.schema.menu import GetMenuDetail
-from backend.common.enums import StatusType
-from backend.common.schema import SchemaBase
-
-
-class RoleSchemaBase(SchemaBase):
-    """角色基础模型"""
-
-    name: str = Field(description='角色名称')
-    status: StatusType = Field(description='状态')
-    is_filter_scopes: bool = Field(True, description='过滤数据权限')
-    remark: str | None = Field(None, description='备注')
-
-
-class CreateRoleParam(RoleSchemaBase):
-    """创建角色参数"""
-
-
-class UpdateRoleParam(RoleSchemaBase):
-    """更新角色参数"""
-
-
-class DeleteRoleParam(SchemaBase):
-    """删除角色参数"""
-
-    pks: list[int] = Field(description='角色 ID 列表')
-
-
-class CreateRoleMenuParam(SchemaBase):
-    """创建角色菜单参数"""
-
-    role_id: int = Field(description='角色 ID')
-    menu_id: int = Field(description='菜单 ID')
-
-
-class UpdateRoleMenuParam(SchemaBase):
-    """更新角色菜单参数"""
-
-    menus: list[int] = Field(description='菜单 ID 列表')
-
-
-class CreateRoleScopeParam(SchemaBase):
-    """创建角色数据范围参数"""
-
-    role_id: int = Field(description='角色 ID')
-    data_scope_id: int = Field(description='数据范围 ID')
-
-
-class UpdateRoleScopeParam(SchemaBase):
-    """更新角色数据范围参数"""
-
-    scopes: list[int] = Field(description='数据范围 ID 列表')
-
-
-class GetRoleDetail(RoleSchemaBase):
-    """角色详情"""
-
-    model_config = ConfigDict(from_attributes=True)
-
-    id: int = Field(description='角色 ID')
-    created_time: datetime = Field(description='创建时间')
-    updated_time: datetime | None = Field(None, description='更新时间')
-
-
-class GetRoleWithRelationDetail(GetRoleDetail):
-    """角色关联详情"""
-
-    menus: list[GetMenuDetail | None] = Field([], description='菜单详情列表')
-    scopes: list[GetDataScopeWithRelationDetail | None] = Field([], description='数据范围列表')

backend/app/admin/schema/user.py

@@ -1,11 +1,8 @@
 from datetime import datetime
-from typing import Annotated, Any
+from typing import Annotated
 
-from pydantic import ConfigDict, Field, HttpUrl, PlainSerializer, model_validator
+from pydantic import ConfigDict, Field, HttpUrl, PlainSerializer
-from typing_extensions import Self
 
-from backend.app.admin.schema.dept import GetDeptDetail
-from backend.app.admin.schema.role import GetRoleWithRelationDetail
 from backend.common.enums import StatusType
 from backend.common.schema import CustomEmailStr, CustomPhoneNumber, SchemaBase, ser_string
 
@@ -30,24 +27,6 @@ class AddUserParam(AuthSchemaBase):
     nickname: str | None = Field(None, description='昵称')
     email: CustomEmailStr | None = Field(None, description='邮箱')
     phone: CustomPhoneNumber | None = Field(None, description='手机号码')
-    dept_id: int = Field(description='部门 ID')
-    roles: list[int] = Field(description='角色 ID 列表')
-
-
-class AddUserRoleParam(SchemaBase):
-    """添加用户角色"""
-
-    user_id: int = Field(description='用户 ID')
-    role_id: int = Field(description='角色 ID')
-
-
-class AddOAuth2UserParam(AuthSchemaBase):
-    """添加 OAuth2 用户参数"""
-
-    password: str | None = Field(None, description='密码')
-    nickname: str | None = Field(None, description='昵称')
-    email: CustomEmailStr | None = Field(None, description='邮箱')
-    avatar: Annotated[HttpUrl, PlainSerializer(ser_string)] | None = Field(None, description='头像地址')
 
 
 class ResetPasswordParam(SchemaBase):
@@ -61,7 +40,6 @@ class ResetPasswordParam(SchemaBase):
 class UserInfoSchemaBase(SchemaBase):
     """用户信息基础模型"""
 
-    dept_id: int | None = Field(None, description='部门 ID')
     username: str = Field(description='用户名')
     nickname: str = Field(description='昵称')
     avatar: Annotated[HttpUrl, PlainSerializer(ser_string)] | None = Field(None, description='头像地址')
@@ -72,15 +50,12 @@ class UserInfoSchemaBase(SchemaBase):
 class UpdateUserParam(UserInfoSchemaBase):
     """更新用户参数"""
 
-    roles: list[int] = Field(description='角色 ID 列表')
-
 
 class GetUserInfoDetail(UserInfoSchemaBase):
     """用户信息详情"""
 
     model_config = ConfigDict(from_attributes=True)
 
-    dept_id: int | None = Field(None, description='部门 ID')
     id: int = Field(description='用户 ID')
     uuid: str = Field(description='用户 UUID')
     status: StatusType = Field(description='状态')
@@ -89,33 +64,3 @@ class GetUserInfoDetail(UserInfoSchemaBase):
     is_multi_login: bool = Field(description='是否允许多端登录')
     join_time: datetime = Field(description='加入时间')
     last_login_time: datetime | None = Field(None, description='最后登录时间')
-
-
-class GetUserInfoWithRelationDetail(GetUserInfoDetail):
-    """用户信息关联详情"""
-
-    model_config = ConfigDict(from_attributes=True)
-
-    dept: GetDeptDetail | None = Field(None, description='部门信息')
-    roles: list[GetRoleWithRelationDetail] = Field(description='角色列表')
-
-
-class GetCurrentUserInfoWithRelationDetail(GetUserInfoWithRelationDetail):
-    """当前用户信息关联详情"""
-
-    model_config = ConfigDict(from_attributes=True)
-
-    dept: str | None = Field(None, description='部门名称')
-    roles: list[str] = Field(description='角色名称列表')
-
-    @model_validator(mode='before')
-    @classmethod
-    def handel(cls, data: Any) -> Self:
-        """处理部门和角色数据"""
-        dept = data['dept']
-        if dept:
-            data['dept'] = dept['name']
-        roles = data['roles']
-        if roles:
-            data['roles'] = [role['name'] for role in roles]
-        return data

backend/app/admin/service/auth_service.py

@@ -1,18 +1,14 @@
 from fastapi import Request, Response
 from fastapi.security import HTTPBasicCredentials
 from sqlalchemy.ext.asyncio import AsyncSession
-from starlette.background import BackgroundTask, BackgroundTasks
 
-from backend.app.admin.crud.crud_menu import menu_dao
 from backend.app.admin.crud.crud_user import user_dao
 from backend.app.admin.model import User
 from backend.app.admin.schema.token import GetLoginToken, GetNewToken
 from backend.app.admin.schema.user import AuthLoginParam
-from backend.app.admin.service.login_log_service import login_log_service
 from backend.app.admin.service.user_password_history_service import password_security_service
 from backend.app.admin.utils.password_security import password_verify
 from backend.common.context import ctx
-from backend.common.enums import LoginLogStatusType
 from backend.common.exception import errors
 from backend.common.i18n import t
 from backend.common.log import log
@@ -25,7 +21,6 @@ from backend.common.security.jwt import (
     jwt_decode,
 )
 from backend.core.conf import settings
-from backend.database.db import uuid4_str
 from backend.database.redis import redis_client
 from backend.utils.dynamic_config import load_login_config
 from backend.utils.timezone import timezone
@@ -86,7 +81,6 @@ class AuthService:
         db: AsyncSession,
         response: Response,
         obj: AuthLoginParam,
-        background_tasks: BackgroundTasks,
     ) -> GetLoginToken:
         """
         用户登录
@@ -94,13 +88,10 @@ class AuthService:
         :param db: 数据库会话
         :param response: 响应对象
         :param obj: 登录参数
-        :param background_tasks: 后台任务
         :return:
         """
         user = None
         try:
-            user, days_remaining = await self.user_verify(db, obj.username, obj.password)
-
             await load_login_config(db)
             if settings.LOGIN_CAPTCHA_ENABLED:
                 if not obj.uuid or not obj.captcha:
@@ -112,6 +103,7 @@ class AuthService:
                     raise errors.CustomError(error=CustomErrorCode.CAPTCHA_ERROR)
                 await redis_client.delete(f'{settings.LOGIN_CAPTCHA_REDIS_PREFIX}:{obj.uuid}')
 
+            user, days_remaining = await self.user_verify(db, obj.username, obj.password)
             await user_dao.update_login_time(db, obj.username)
             await db.refresh(user)
             access_token_data = await create_access_token(
@@ -143,30 +135,12 @@ class AuthService:
             raise errors.NotFoundError(msg=e.msg)
         except (errors.RequestError, errors.CustomError) as e:
             if not user:
-                log.error('登陆错误: 用户密码有误')
+                log.error(f'登陆错误: {e.msg}')
-            task = BackgroundTask(
+            raise errors.RequestError(code=e.code, msg=e.msg)
-                login_log_service.create,
-                db=db,
-                user_uuid=user.uuid if user else uuid4_str(),
-                username=obj.username,
-                login_time=timezone.now(),
-                status=LoginLogStatusType.fail.value,
-                msg=e.msg,
-            )
-            raise errors.RequestError(code=e.code, msg=e.msg, background=task)
         except Exception as e:
             log.error(f'登陆错误: {e}')
             raise
         else:
-            background_tasks.add_task(
-                login_log_service.create,
-                db=db,
-                user_uuid=user.uuid,
-                username=obj.username,
-                login_time=timezone.now(),
-                status=LoginLogStatusType.success.value,
-                msg=t('success.login.success'),
-            )
             data = GetLoginToken(
                 access_token=access_token_data.access_token,
                 access_token_expire_time=access_token_data.access_token_expire_time,
@@ -177,50 +151,29 @@ class AuthService:
             return data
 
     @staticmethod
-    async def get_codes(*, db: AsyncSession, request: Request) -> list[str]:
+    async def refresh_token(*, db: AsyncSession, request: Request, response: Response) -> GetNewToken:
-        """
-        获取用户权限码
-
-        :param db: 数据库会话
-        :param request: FastAPI 请求对象
-        :return:
-        """
-        codes = set()
-        if request.user.is_superuser:
-            menus = await menu_dao.get_all(db, None, None)
-            for menu in menus:
-                if menu.perms:
-                    codes.add(*menu.perms.split(','))
-        else:
-            roles = request.user.roles
-            if roles:
-                for role in roles:
-                    for menu in role.menus:
-                        if menu.perms:
-                            codes.add(*menu.perms.split(','))
-
-        return list(codes)
-
-    @staticmethod
-    async def refresh_token(*, db: AsyncSession, request: Request) -> GetNewToken:
         """
         刷新令牌
 
         :param db: 数据库会话
         :param request: FastAPI 请求对象
+        :param response: FastAPI 响应对象
         :return:
         """
         refresh_token = request.cookies.get(settings.COOKIE_REFRESH_TOKEN_KEY)
         if not refresh_token:
             raise errors.RequestError(msg='Refresh Token 已过期，请重新登录')
-        token_payload = jwt_decode(refresh_token)
 
-        user = await user_dao.get(db, token_payload.id)
+        token_payload = jwt_decode(refresh_token)
+        user = await user_dao.get(db, token_payload.user_id)
         if not user:
             raise errors.NotFoundError(msg='用户不存在')
         if not user.status:
             raise errors.AuthorizationError(msg='用户已被锁定, 请联系统管理员')
-        if not user.is_multi_login and await redis_client.get_prefix(f'{settings.TOKEN_REDIS_PREFIX}:{user.id}:*'):
+        token_keys = await redis_client.get_by_prefix(f'{settings.TOKEN_REDIS_PREFIX}:{user.id}')
+        if not user.is_multi_login and [
+            key for key in token_keys if not key.endswith(f':{token_payload.session_uuid}')
+        ]:
             raise errors.ForbiddenError(msg='此用户已在异地登录，请重新登录并及时修改密码')
         new_token = await create_new_token(
             refresh_token,
@@ -236,6 +189,13 @@ class AuthService:
             browser=ctx.browser,
             device_type=ctx.device,
         )
+        response.set_cookie(
+            key=settings.COOKIE_REFRESH_TOKEN_KEY,
+            value=new_token.new_refresh_token,
+            max_age=settings.COOKIE_REFRESH_TOKEN_EXPIRE_SECONDS,
+            expires=timezone.to_utc(new_token.new_refresh_token_expire_time),
+            httponly=True,
+        )
         data = GetNewToken(
             access_token=new_token.new_access_token,
             access_token_expire_time=new_token.new_access_token_expire_time,
@@ -255,7 +215,7 @@ class AuthService:
         try:
             token = get_token(request)
             token_payload = jwt_decode(token)
-            user_id = token_payload.id
+            user_id = token_payload.user_id
             session_uuid = token_payload.session_uuid
             refresh_token = request.cookies.get(settings.COOKIE_REFRESH_TOKEN_KEY)
         except errors.TokenError:
@@ -266,7 +226,7 @@ class AuthService:
         await redis_client.delete(f'{settings.TOKEN_REDIS_PREFIX}:{user_id}:{session_uuid}')
         await redis_client.delete(f'{settings.TOKEN_EXTRA_INFO_REDIS_PREFIX}:{user_id}:{session_uuid}')
         if refresh_token:
-            await redis_client.delete(f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{user_id}:{refresh_token}')
+            await redis_client.delete(f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{user_id}:{session_uuid}')
 
 
 auth_service: AuthService = AuthService()

backend/app/admin/service/data_rule_service.py

@@ -1,134 +0,0 @@
-from collections.abc import Sequence
-from typing import Any
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from backend.app.admin.crud.crud_data_rule import data_rule_dao
-from backend.app.admin.model import DataRule
-from backend.app.admin.schema.data_rule import (
-    CreateDataRuleParam,
-    DeleteDataRuleParam,
-    GetDataRuleColumnDetail,
-    UpdateDataRuleParam,
-)
-from backend.app.admin.utils.cache import user_cache_manager
-from backend.common.exception import errors
-from backend.common.pagination import paging_data
-from backend.core.conf import settings
-from backend.utils.import_parse import dynamic_import_data_model
-
-
-class DataRuleService:
-    """数据规则服务类"""
-
-    @staticmethod
-    async def get(*, db: AsyncSession, pk: int) -> DataRule:
-        """
-        获取数据规则详情
-
-        :param db: 数据库会话
-        :param pk: 规则 ID
-        :return:
-        """
-
-        data_rule = await data_rule_dao.get(db, pk)
-        if not data_rule:
-            raise errors.NotFoundError(msg='数据规则不存在')
-        return data_rule
-
-    @staticmethod
-    async def get_models() -> list[str]:
-        """获取所有数据规则可用模型"""
-        return list(settings.DATA_PERMISSION_MODELS.keys())
-
-    @staticmethod
-    async def get_columns(model: str) -> list[GetDataRuleColumnDetail]:
-        """
-        获取数据规则可用模型的字段列表
-
-        :param model: 模型名称
-        :return:
-        """
-        if model not in settings.DATA_PERMISSION_MODELS:
-            raise errors.NotFoundError(msg='数据规则可用模型不存在')
-        model_ins = dynamic_import_data_model(settings.DATA_PERMISSION_MODELS[model])
-
-        model_columns = [
-            GetDataRuleColumnDetail(key=column.key, comment=column.comment)
-            for column in model_ins.__table__.columns
-            if column.key not in settings.DATA_PERMISSION_COLUMN_EXCLUDE
-        ]
-        return model_columns
-
-    @staticmethod
-    async def get_list(*, db: AsyncSession, name: str | None) -> dict[str, Any]:
-        """
-        获取数据规则列表
-
-        :param db: 数据库会话
-        :param name: 规则名称
-        :return:
-        """
-        data_rule_select = await data_rule_dao.get_select(name=name)
-        return await paging_data(db, data_rule_select)
-
-    @staticmethod
-    async def get_all(*, db: AsyncSession) -> Sequence[DataRule]:
-        """
-        获取所有数据规则
-
-        :param db: 数据库会话
-        :return:
-        """
-
-        data_rules = await data_rule_dao.get_all(db)
-        return data_rules
-
-    @staticmethod
-    async def create(*, db: AsyncSession, obj: CreateDataRuleParam) -> None:
-        """
-        创建数据规则
-
-        :param db: 数据库会话
-        :param obj: 规则创建参数
-        :return:
-        """
-        data_rule = await data_rule_dao.get_by_name(db, obj.name)
-        if data_rule:
-            raise errors.ConflictError(msg='数据规则已存在')
-        await data_rule_dao.create(db, obj)
-
-    @staticmethod
-    async def update(*, db: AsyncSession, pk: int, obj: UpdateDataRuleParam) -> int:
-        """
-        更新数据规则
-
-        :param db: 数据库会话
-        :param pk: 规则 ID
-        :param obj: 规则更新参数
-        :return:
-        """
-        data_rule = await data_rule_dao.get(db, pk)
-        if not data_rule:
-            raise errors.NotFoundError(msg='数据规则不存在')
-        if data_rule.name != obj.name and await data_rule_dao.get_by_name(db, obj.name):
-            raise errors.ConflictError(msg='数据规则已存在')
-        count = await data_rule_dao.update(db, pk, obj)
-        await user_cache_manager.clear_by_data_rule_id(db, [pk])
-        return count
-
-    @staticmethod
-    async def delete(*, db: AsyncSession, obj: DeleteDataRuleParam) -> int:
-        """
-        批量删除数据规则
-
-        :param db: 数据库会话
-        :param obj: 规则 ID 列表
-        :return:
-        """
-        count = await data_rule_dao.delete(db, obj.pks)
-        await user_cache_manager.clear_by_data_rule_id(db, obj.pks)
-        return count
-
-
-data_rule_service: DataRuleService = DataRuleService()

backend/app/admin/service/data_scope_service.py

@@ -1,138 +0,0 @@
-from collections.abc import Sequence
-from typing import Any
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from backend.app.admin.crud.crud_data_scope import data_scope_dao
-from backend.app.admin.model import DataScope
-from backend.app.admin.schema.data_scope import (
-    CreateDataScopeParam,
-    DeleteDataScopeParam,
-    UpdateDataScopeParam,
-    UpdateDataScopeRuleParam,
-)
-from backend.app.admin.utils.cache import user_cache_manager
-from backend.common.exception import errors
-from backend.common.pagination import paging_data
-
-
-class DataScopeService:
-    """数据范围服务类"""
-
-    @staticmethod
-    async def get(*, db: AsyncSession, pk: int) -> DataScope:
-        """
-        获取数据范围详情
-
-        :param db: 数据库会话
-        :param pk: 范围 ID
-        :return:
-        """
-
-        data_scope = await data_scope_dao.get(db, pk)
-        if not data_scope:
-            raise errors.NotFoundError(msg='数据范围不存在')
-        return data_scope
-
-    @staticmethod
-    async def get_all(*, db: AsyncSession) -> Sequence[DataScope]:
-        """
-        获取所有数据范围
-
-        :param db: 数据库会话
-        :return:
-        """
-
-        data_scopes = await data_scope_dao.get_all(db)
-        return data_scopes
-
-    @staticmethod
-    async def get_rules(*, db: AsyncSession, pk: int) -> DataScope:
-        """
-        获取数据范围规则
-
-        :param db: 数据库会话
-        :param pk: 范围 ID
-        :return:
-        """
-
-        data_scope = await data_scope_dao.get_join(db, pk)
-        if not data_scope:
-            raise errors.NotFoundError(msg='数据范围不存在')
-        return data_scope
-
-    @staticmethod
-    async def get_list(*, db: AsyncSession, name: str | None, status: int | None) -> dict[str, Any]:
-        """
-        获取数据范围列表
-
-        :param db: 数据库会话
-        :param name: 范围名称
-        :param status: 范围状态
-        :return:
-        """
-        data_scope_select = await data_scope_dao.get_select(name, status)
-        return await paging_data(db, data_scope_select)
-
-    @staticmethod
-    async def create(*, db: AsyncSession, obj: CreateDataScopeParam) -> None:
-        """
-        创建数据范围
-
-        :param db: 数据库会话
-        :param obj: 数据范围参数
-        :return:
-        """
-        data_scope = await data_scope_dao.get_by_name(db, obj.name)
-        if data_scope:
-            raise errors.ConflictError(msg='数据范围已存在')
-        await data_scope_dao.create(db, obj)
-
-    @staticmethod
-    async def update(*, db: AsyncSession, pk: int, obj: UpdateDataScopeParam) -> int:
-        """
-        更新数据范围
-
-        :param db: 数据库会话
-        :param pk: 范围 ID
-        :param obj: 数据范围更新参数
-        :return:
-        """
-        data_scope = await data_scope_dao.get(db, pk)
-        if not data_scope:
-            raise errors.NotFoundError(msg='数据范围不存在')
-        if data_scope.name != obj.name and await data_scope_dao.get_by_name(db, obj.name):
-            raise errors.ConflictError(msg='数据范围已存在')
-        count = await data_scope_dao.update(db, pk, obj)
-        await user_cache_manager.clear_by_data_scope_id(db, [pk])
-        return count
-
-    @staticmethod
-    async def update_data_scope_rule(*, db: AsyncSession, pk: int, rule_ids: UpdateDataScopeRuleParam) -> int:
-        """
-        更新数据范围规则
-
-        :param db: 数据库会话
-        :param pk: 范围 ID
-        :param rule_ids: 规则 ID 列表
-        :return:
-        """
-        count = await data_scope_dao.update_rules(db, pk, rule_ids)
-        await user_cache_manager.clear_by_data_scope_id(db, [pk])
-        return count
-
-    @staticmethod
-    async def delete(*, db: AsyncSession, obj: DeleteDataScopeParam) -> int:
-        """
-        批量删除数据范围
-
-        :param db: 数据库会话
-        :param obj: 范围 ID 列表
-        :return:
-        """
-        count = await data_scope_dao.delete(db, obj.pks)
-        await user_cache_manager.clear_by_data_scope_id(db, obj.pks)
-        return count
-
-
-data_scope_service: DataScopeService = DataScopeService()

backend/app/admin/service/dept_service.py

@@ -1,124 +0,0 @@
-from typing import Any
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from backend.app.admin.crud.crud_dept import dept_dao
-from backend.app.admin.model import Dept
-from backend.app.admin.schema.dept import CreateDeptParam, UpdateDeptParam
-from backend.app.admin.schema.user import GetUserInfoWithRelationDetail
-from backend.common.exception import errors
-from backend.core.conf import settings
-from backend.database.redis import redis_client
-from backend.utils.build_tree import get_tree_data
-
-
-class DeptService:
-    """部门服务类"""
-
-    @staticmethod
-    async def get(*, db: AsyncSession, pk: int) -> Dept:
-        """
-        获取部门详情
-
-        :param db: 数据库会话
-        :param pk: 部门 ID
-        :return:
-        """
-
-        dept = await dept_dao.get(db, pk)
-        if not dept:
-            raise errors.NotFoundError(msg='部门不存在')
-        return dept
-
-    @staticmethod
-    async def get_tree(
-        *,
-        db: AsyncSession,
-        request_user: GetUserInfoWithRelationDetail,
-        name: str | None,
-        leader: str | None,
-        phone: str | None,
-        status: int | None,
-    ) -> list[dict[str, Any]]:
-        """
-        获取部门树形结构
-
-        :param db: 数据库会话
-        :param request_user: 请求用户
-        :param name: 部门名称
-        :param leader: 部门负责人
-        :param phone: 联系电话
-        :param status: 状态
-        :return:
-        """
-
-        dept_select = await dept_dao.get_all(db, request_user, name, leader, phone, status)
-        tree_data = get_tree_data(dept_select)
-        return tree_data
-
-    @staticmethod
-    async def create(*, db: AsyncSession, obj: CreateDeptParam) -> None:
-        """
-        创建部门
-
-        :param db: 数据库会话
-        :param obj: 部门创建参数
-        :return:
-        """
-        dept = await dept_dao.get_by_name(db, obj.name)
-        if dept:
-            raise errors.ConflictError(msg='部门名称已存在')
-        if obj.parent_id is not None:
-            parent_dept = await dept_dao.get(db, obj.parent_id)
-            if not parent_dept:
-                raise errors.NotFoundError(msg='父级部门不存在')
-        await dept_dao.create(db, obj)
-
-    @staticmethod
-    async def update(*, db: AsyncSession, pk: int, obj: UpdateDeptParam) -> int:
-        """
-        更新部门
-
-        :param db: 数据库会话
-        :param pk: 部门 ID
-        :param obj: 部门更新参数
-        :return:
-        """
-        dept = await dept_dao.get(db, pk)
-        if not dept:
-            raise errors.NotFoundError(msg='部门不存在')
-        if dept.name != obj.name and await dept_dao.get_by_name(db, obj.name):
-            raise errors.ConflictError(msg='部门名称已存在')
-        if obj.parent_id:
-            parent_dept = await dept_dao.get(db, obj.parent_id)
-            if not parent_dept:
-                raise errors.NotFoundError(msg='父级部门不存在')
-        if obj.parent_id == dept.id:
-            raise errors.ForbiddenError(msg='禁止关联自身为父级')
-        count = await dept_dao.update(db, pk, obj)
-        return count
-
-    @staticmethod
-    async def delete(*, db: AsyncSession, pk: int) -> int:
-        """
-        删除部门
-
-        :param db: 数据库会话
-        :param pk: 部门 ID
-        :return:
-        """
-        dept = await dept_dao.get_join(db, pk)
-        if not dept:
-            raise errors.NotFoundError(msg='部门不存在')
-        if dept.users:
-            raise errors.ConflictError(msg='部门下存在用户，无法删除')
-        children = await dept_dao.get_children(db, pk)
-        if children:
-            raise errors.ConflictError(msg='部门下存在子部门，无法删除')
-        count = await dept_dao.delete(db, pk)
-        for user in dept.users:
-            await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{user.id}')
-        return count
-
-
-dept_service: DeptService = DeptService()

backend/app/admin/service/login_log_service.py

@@ -1,89 +0,0 @@
-from datetime import datetime
-from typing import Any
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from backend.app.admin.crud.crud_login_log import login_log_dao
-from backend.app.admin.schema.login_log import CreateLoginLogParam, DeleteLoginLogParam
-from backend.common.context import ctx
-from backend.common.log import log
-from backend.common.pagination import paging_data
-
-
-class LoginLogService:
-    """登录日志服务类"""
-
-    @staticmethod
-    async def get_list(*, db: AsyncSession, username: str | None, status: int | None, ip: str | None) -> dict[str, Any]:
-        """
-        获取登录日志列表
-
-        :param db: 数据库会话
-        :param username: 用户名
-        :param status: 状态
-        :param ip: IP 地址
-        :return:
-        """
-        log_select = await login_log_dao.get_select(username=username, status=status, ip=ip)
-        return await paging_data(db, log_select)
-
-    @staticmethod
-    async def create(
-        *,
-        db: AsyncSession,
-        user_uuid: str,
-        username: str,
-        login_time: datetime,
-        status: int,
-        msg: str,
-    ) -> None:
-        """
-        创建登录日志
-
-        :param db: 数据库会话
-        :param user_uuid: 用户 UUID
-        :param username: 用户名
-        :param login_time: 登录时间
-        :param status: 状态
-        :param msg: 消息
-        :return:
-        """
-        try:
-            obj = CreateLoginLogParam(
-                user_uuid=user_uuid,
-                username=username,
-                status=status,
-                ip=ctx.ip,
-                country=ctx.country,
-                region=ctx.region,
-                city=ctx.city,
-                user_agent=ctx.user_agent,
-                browser=ctx.browser,
-                os=ctx.os,
-                device=ctx.device,
-                msg=msg,
-                login_time=login_time,
-            )
-            await login_log_dao.create(db, obj)
-        except Exception as e:
-            log.error(f'登录日志创建失败: {e}')
-
-    @staticmethod
-    async def delete(*, db: AsyncSession, obj: DeleteLoginLogParam) -> int:
-        """
-        批量删除登录日志
-
-        :param db: 数据库会话
-        :param obj: 日志 ID 列表
-        :return:
-        """
-        count = await login_log_dao.delete(db, obj.pks)
-        return count
-
-    @staticmethod
-    async def delete_all(*, db: AsyncSession) -> None:
-        """清空所有登录日志"""
-        await login_log_dao.delete_all(db)
-
-
-login_log_service: LoginLogService = LoginLogService()

backend/app/admin/service/menu_service.py

@@ -1,136 +0,0 @@
-from typing import Any
-
-from fastapi import Request
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from backend.app.admin.crud.crud_menu import menu_dao
-from backend.app.admin.model import Menu
-from backend.app.admin.schema.menu import CreateMenuParam, UpdateMenuParam
-from backend.app.admin.utils.cache import user_cache_manager
-from backend.common.exception import errors
-from backend.utils.build_tree import get_tree_data, get_vben5_tree_data
-
-
-class MenuService:
-    """菜单服务类"""
-
-    @staticmethod
-    async def get(*, db: AsyncSession, pk: int) -> Menu:
-        """
-        获取菜单详情
-
-        :param db: 数据库会话
-        :param pk: 菜单 ID
-        :return:
-        """
-
-        menu = await menu_dao.get(db, menu_id=pk)
-        if not menu:
-            raise errors.NotFoundError(msg='菜单不存在')
-        return menu
-
-    @staticmethod
-    async def get_tree(*, db: AsyncSession, title: str | None, status: int | None) -> list[dict[str, Any]]:
-        """
-        获取菜单树形结构
-
-        :param db: 数据库会话
-        :param title: 菜单标题
-        :param status: 状态
-        :return:
-        """
-
-        menu_data = await menu_dao.get_all(db, title=title, status=status)
-        menu_tree = get_tree_data(menu_data)
-        return menu_tree
-
-    @staticmethod
-    async def get_sidebar(*, db: AsyncSession, request: Request) -> list[dict[str, Any] | None]:
-        """
-        获取用户的菜单侧边栏
-
-        :param db: 数据库会话
-        :param request: FastAPI 请求对象
-        :return:
-        """
-        menu_data = None
-        if request.user.is_superuser:
-            menu_data = await menu_dao.get_sidebar(db, None)
-        else:
-            roles = request.user.roles
-            menu_ids = set()
-            if roles:
-                for role in roles:
-                    menu_ids.update(menu.id for menu in role.menus)
-                menu_data = await menu_dao.get_sidebar(db, list(menu_ids))
-
-        if menu_data:
-            return get_vben5_tree_data(menu_data)
-
-        return []
-
-    @staticmethod
-    async def create(*, db: AsyncSession, obj: CreateMenuParam) -> None:
-        """
-        创建菜单
-
-        :param db: 数据库会话
-        :param obj: 菜单创建参数
-        :return:
-        """
-
-        title = await menu_dao.get_by_title(db, obj.title)
-        if title:
-            raise errors.ConflictError(msg='菜单标题已存在')
-        if obj.parent_id:
-            parent_menu = await menu_dao.get(db, obj.parent_id)
-            if not parent_menu:
-                raise errors.NotFoundError(msg='父级菜单不存在')
-        await menu_dao.create(db, obj)
-
-    @staticmethod
-    async def update(*, db: AsyncSession, pk: int, obj: UpdateMenuParam) -> int:
-        """
-        更新菜单
-
-        :param db: 数据库会话
-        :param pk: 菜单 ID
-        :param obj: 菜单更新参数
-        :return:
-        """
-
-        menu = await menu_dao.get(db, pk)
-        if not menu:
-            raise errors.NotFoundError(msg='菜单不存在')
-        if menu.title != obj.title and await menu_dao.get_by_title(db, obj.title):
-            raise errors.ConflictError(msg='菜单标题已存在')
-        if obj.parent_id:
-            parent_menu = await menu_dao.get(db, obj.parent_id)
-            if not parent_menu:
-                raise errors.NotFoundError(msg='父级菜单不存在')
-        if obj.parent_id == menu.id:
-            raise errors.ForbiddenError(msg='禁止关联自身为父级')
-        count = await menu_dao.update(db, pk, obj)
-        await user_cache_manager.clear_by_menu_id(db, [pk])
-        return count
-
-    @staticmethod
-    async def delete(*, db: AsyncSession, pk: int) -> int:
-        """
-        删除菜单
-
-        :param db: 数据库会话
-        :param pk: 菜单 ID
-        :return:
-        """
-
-        children = await menu_dao.get_children(db, pk)
-        if children:
-            raise errors.ConflictError(msg='菜单下存在子菜单，无法删除')
-        count = await menu_dao.delete(db, pk)
-        if count:
-            await user_cache_manager.clear_by_menu_id(db, [pk])
-        return count
-
-
-menu_service: MenuService = MenuService()

backend/app/admin/service/opera_log_service.py

@@ -1,72 +0,0 @@
-from typing import Any
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from backend.app.admin.crud.crud_opera_log import opera_log_dao
-from backend.app.admin.schema.opera_log import CreateOperaLogParam, DeleteOperaLogParam
-from backend.common.pagination import paging_data
-
-
-class OperaLogService:
-    """操作日志服务类"""
-
-    @staticmethod
-    async def get_list(*, db: AsyncSession, username: str | None, status: int | None, ip: str | None) -> dict[str, Any]:
-        """
-        获取操作日志列表
-
-        :param db: 数据库会话
-        :param username: 用户名
-        :param status: 状态
-        :param ip: IP 地址
-        :return:
-        """
-        log_select = await opera_log_dao.get_select(username=username, status=status, ip=ip)
-        return await paging_data(db, log_select)
-
-    @staticmethod
-    async def create(*, db: AsyncSession, obj: CreateOperaLogParam) -> None:
-        """
-        创建操作日志
-
-        :param db: 数据库会话
-        :param obj: 操作日志创建参数
-        :return:
-        """
-        await opera_log_dao.create(db, obj)
-
-    @staticmethod
-    async def bulk_create(*, db: AsyncSession, objs: list[CreateOperaLogParam]) -> None:
-        """
-        批量创建操作日志
-
-        :param db: 数据库会话
-        :param objs: 操作日志创建参数列表
-        :return:
-        """
-        await opera_log_dao.bulk_create(db, objs)
-
-    @staticmethod
-    async def delete(*, db: AsyncSession, obj: DeleteOperaLogParam) -> int:
-        """
-        批量删除操作日志
-
-        :param db: 数据库会话
-        :param obj: 日志 ID 列表
-        :return:
-        """
-        count = await opera_log_dao.delete(db, obj.pks)
-        return count
-
-    @staticmethod
-    async def delete_all(*, db: AsyncSession) -> None:
-        """
-        清空所有操作日志
-
-        :param db: 数据库会话
-        :return:
-        """
-        await opera_log_dao.delete_all(db)
-
-
-opera_log_service: OperaLogService = OperaLogService()

backend/app/admin/service/plugin_service.py

@@ -1,22 +1,21 @@
 import io
 import json
-import os
-import shutil
-import zipfile
 
 from typing import Any
 
 import anyio
 
 from fastapi import UploadFile
+from starlette.concurrency import run_in_threadpool
 
 from backend.common.enums import PluginType, StatusType
 from backend.common.exception import errors
 from backend.core.conf import settings
 from backend.core.path_conf import PLUGIN_DIR
 from backend.database.redis import redis_client
-from backend.plugin.tools import uninstall_requirements_async
+from backend.plugin.core import get_required_plugins
-from backend.utils.file_ops import install_git_plugin, install_zip_plugin
+from backend.plugin.installer import install_git_plugin, install_zip_plugin, remove_plugin, zip_plugin
+from backend.plugin.requirements import uninstall_requirements_async
 from backend.utils.timezone import timezone
 
 
@@ -27,9 +26,20 @@ class PluginService:
     async def get_all() -> list[dict[str, Any]]:
         """获取所有插件"""
 
-        keys = [key async for key in redis_client.scan_iter(f'{settings.PLUGIN_REDIS_PREFIX}:*')]
+        changed_key = f'{settings.PLUGIN_REDIS_PREFIX}:changed'
+        keys = [key for key in await redis_client.get_by_prefix(settings.PLUGIN_REDIS_PREFIX) if key != changed_key]
+        if not keys:
+            return []
 
-        result = [json.loads(info) for info in await redis_client.mget(*keys)]
+        result = []
+        plugin_infos = await redis_client.mget(*keys)
+        for info in plugin_infos:
+            if info is None:
+                continue
+
+            plugin_info = json.loads(info)
+            if isinstance(plugin_info, dict):
+                result.append(plugin_info)
 
         return result
 
@@ -68,14 +78,17 @@ class PluginService:
         """
         if settings.ENVIRONMENT != 'dev':
             raise errors.RequestError(msg='禁止在非开发环境下卸载插件')
+        if plugin in get_required_plugins():
+            raise errors.RequestError(msg=f'插件 {plugin} 为必需插件，禁止卸载')
         plugin_dir = anyio.Path(PLUGIN_DIR / plugin)
         if not await plugin_dir.exists():
             raise errors.NotFoundError(msg='插件不存在')
         await uninstall_requirements_async(plugin)
-        bacup_dir = PLUGIN_DIR / f'{plugin}.{timezone.now().strftime("%Y%m%d%H%M%S")}.backup'
+        backup_file = PLUGIN_DIR / f'{plugin}.{timezone.now().strftime("%Y%m%d%H%M%S")}.backup.zip'
-        shutil.move(plugin_dir, bacup_dir)
+        await run_in_threadpool(zip_plugin, plugin_dir, backup_file)
+        await run_in_threadpool(remove_plugin, plugin_dir)
         await redis_client.delete(f'{settings.PLUGIN_REDIS_PREFIX}:{plugin}')
-        await redis_client.set(f'{settings.PLUGIN_REDIS_PREFIX}:changed', 'ture')
+        await redis_client.set(f'{settings.PLUGIN_REDIS_PREFIX}:changed', 'true')
 
     @staticmethod
     async def update_status(*, plugin: str) -> None:
@@ -85,7 +98,8 @@ class PluginService:
         :param plugin: 插件名称
         :return:
         """
-        plugin_info = await redis_client.get(f'{settings.PLUGIN_REDIS_PREFIX}:{plugin}')
+        plugin_key = f'{settings.PLUGIN_REDIS_PREFIX}:{plugin}'
+        plugin_info = await redis_client.get(plugin_key)
         if not plugin_info:
             raise errors.NotFoundError(msg='插件不存在')
         plugin_info = json.loads(plugin_info)
@@ -97,7 +111,8 @@ class PluginService:
             else str(StatusType.disable.value)
         )
         plugin_info['plugin']['enable'] = new_status
-        await redis_client.set(f'{settings.PLUGIN_REDIS_PREFIX}:{plugin}', json.dumps(plugin_info, ensure_ascii=False))
+        await redis_client.set(plugin_key, json.dumps(plugin_info, ensure_ascii=False))
+        await redis_client.set(f'{settings.PLUGIN_REDIS_PREFIX}:changed', 'true')
 
     @staticmethod
     async def build(*, plugin: str) -> io.BytesIO:
@@ -112,14 +127,7 @@ class PluginService:
             raise errors.NotFoundError(msg='插件不存在')
 
         bio = io.BytesIO()
-        with zipfile.ZipFile(bio, 'w') as zf:
+        await run_in_threadpool(zip_plugin, plugin_dir, bio)
-            for root, dirs, files in os.walk(plugin_dir):
-                dirs[:] = [d for d in dirs if d != '__pycache__']
-                for file in files:
-                    file_path = os.path.join(root, file)
-                    arcname = os.path.relpath(file_path, start=plugin_dir)  # noqa: ASYNC240
-                    zf.write(file_path, os.path.join(plugin, arcname))
-
         bio.seek(0)
         return bio
 

backend/app/admin/service/role_service.py

@@ -1,193 +0,0 @@
-from collections.abc import Sequence
-from typing import Any
-
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from backend.app.admin.crud.crud_data_scope import data_scope_dao
-from backend.app.admin.crud.crud_menu import menu_dao
-from backend.app.admin.crud.crud_role import role_dao
-from backend.app.admin.model import Role
-from backend.app.admin.schema.role import (
-    CreateRoleParam,
-    DeleteRoleParam,
-    UpdateRoleMenuParam,
-    UpdateRoleParam,
-    UpdateRoleScopeParam,
-)
-from backend.app.admin.utils.cache import user_cache_manager
-from backend.common.exception import errors
-from backend.common.pagination import paging_data
-from backend.utils.build_tree import get_tree_data
-
-
-class RoleService:
-    """角色服务类"""
-
-    @staticmethod
-    async def get(*, db: AsyncSession, pk: int) -> Role:
-        """
-        获取角色详情
-
-        :param db: 数据库会话
-        :param pk: 角色 ID
-        :return:
-        """
-
-        role = await role_dao.get_join(db, pk)
-        if not role:
-            raise errors.NotFoundError(msg='角色不存在')
-        return role
-
-    @staticmethod
-    async def get_all(*, db: AsyncSession) -> Sequence[Role]:
-        """
-        获取所有角色
-
-        :param db: 数据库会话
-        :return:
-        """
-
-        roles = await role_dao.get_all(db)
-        return roles
-
-    @staticmethod
-    async def get_list(*, db: AsyncSession, name: str | None, status: int | None) -> dict[str, Any]:
-        """
-        获取角色列表
-
-        :param db: 数据库会话
-        :param name: 角色名称
-        :param status: 状态
-        :return:
-        """
-        role_select = await role_dao.get_select(name=name, status=status)
-        return await paging_data(db, role_select)
-
-    @staticmethod
-    async def get_menu_tree(*, db: AsyncSession, pk: int) -> list[dict[str, Any] | None]:
-        """
-        获取角色的菜单树形结构
-
-        :param db: 数据库会话
-        :param pk: 角色 ID
-        :return:
-        """
-
-        role = await role_dao.get(db, pk)
-        if not role:
-            raise errors.NotFoundError(msg='角色不存在')
-        menus = await role_dao.get_menus(db, pk)
-        menu_tree = get_tree_data(menus) if menus else []
-        return menu_tree
-
-    @staticmethod
-    async def get_scopes(*, db: AsyncSession, pk: int) -> list[int]:
-        """
-        获取角色数据范围列表
-
-        :param db: 数据库会话
-        :param pk:
-        :return:
-        """
-
-        role = await role_dao.get_join(db, pk)
-        if not role:
-            raise errors.NotFoundError(msg='角色不存在')
-        scope_ids = [scope.id for scope in role.scopes]
-        return scope_ids
-
-    @staticmethod
-    async def create(*, db: AsyncSession, obj: CreateRoleParam) -> None:
-        """
-        创建角色
-
-        :param db: 数据库会话
-        :param obj: 角色创建参数
-        :return:
-        """
-
-        role = await role_dao.get_by_name(db, obj.name)
-        if role:
-            raise errors.ConflictError(msg='角色已存在')
-        await role_dao.create(db, obj)
-
-    @staticmethod
-    async def update(*, db: AsyncSession, pk: int, obj: UpdateRoleParam) -> int:
-        """
-        更新角色
-
-        :param db: 数据库会话
-        :param pk: 角色 ID
-        :param obj: 角色更新参数
-        :return:
-        """
-
-        role = await role_dao.get(db, pk)
-        if not role:
-            raise errors.NotFoundError(msg='角色不存在')
-        if role.name != obj.name and await role_dao.get_by_name(db, obj.name):
-            raise errors.ConflictError(msg='角色已存在')
-        count = await role_dao.update(db, pk, obj)
-        await user_cache_manager.clear_by_role_id(db, [pk])
-        return count
-
-    @staticmethod
-    async def update_role_menu(*, db: AsyncSession, pk: int, menu_ids: UpdateRoleMenuParam) -> int:
-        """
-        更新角色菜单
-
-        :param db: 数据库会话
-        :param pk: 角色 ID
-        :param menu_ids: 菜单 ID 列表
-        :return:
-        """
-
-        role = await role_dao.get(db, pk)
-        if not role:
-            raise errors.NotFoundError(msg='角色不存在')
-        for menu_id in menu_ids.menus:
-            menu = await menu_dao.get(db, menu_id)
-            if not menu:
-                raise errors.NotFoundError(msg='菜单不存在')
-        count = await role_dao.update_menus(db, pk, menu_ids)
-        await user_cache_manager.clear_by_role_id(db, [pk])
-        return count
-
-    @staticmethod
-    async def update_role_scope(*, db: AsyncSession, pk: int, scope_ids: UpdateRoleScopeParam) -> int:
-        """
-        更新角色数据范围
-
-        :param db: 数据库会话
-        :param pk: 角色 ID
-        :param scope_ids: 权限规则 ID 列表
-        :return:
-        """
-
-        role = await role_dao.get(db, pk)
-        if not role:
-            raise errors.NotFoundError(msg='角色不存在')
-        for scope_id in scope_ids.scopes:
-            scope = await data_scope_dao.get(db, scope_id)
-            if not scope:
-                raise errors.NotFoundError(msg='数据范围不存在')
-        count = await role_dao.update_scopes(db, pk, scope_ids)
-        await user_cache_manager.clear_by_role_id(db, [pk])
-        return count
-
-    @staticmethod
-    async def delete(*, db: AsyncSession, obj: DeleteRoleParam) -> int:
-        """
-        批量删除角色
-
-        :param db: 数据库会话
-        :param obj: 角色 ID 列表
-        :return:
-        """
-
-        count = await role_dao.delete(db, obj.pks)
-        await user_cache_manager.clear_by_role_id(db, obj.pks)
-        return count
-
-
-role_service: RoleService = RoleService()

backend/app/admin/service/user_password_history_service.py

@@ -57,11 +57,19 @@ class UserPasswordHistoryService:
         failure_count = await redis_client.get(f'{settings.LOGIN_FAILURE_PREFIX}:{user_id}')
         failure_count = int(failure_count) if failure_count else 0
         failure_count += 1
-        await redis_client.set(f'{settings.LOGIN_FAILURE_PREFIX}:{user_id}', str(failure_count))
+        await redis_client.set(
+            f'{settings.LOGIN_FAILURE_PREFIX}:{user_id}',
+            str(failure_count),
+            ex=settings.USER_LOCK_SECONDS,
+        )
 
         if failure_count >= settings.USER_LOCK_THRESHOLD:
             locked_until = timezone.now() + timedelta(seconds=settings.USER_LOCK_SECONDS)
-            await redis_client.set(f'{settings.USER_LOCK_REDIS_PREFIX}:{user_id}', timezone.to_str(locked_until))
+            await redis_client.set(
+                f'{settings.USER_LOCK_REDIS_PREFIX}:{user_id}',
+                timezone.to_str(locked_until),
+                ex=settings.USER_LOCK_SECONDS,
+            )
             raise errors.AuthorizationError(msg='登录失败次数过多，账号已被锁定')
 
     @staticmethod

backend/app/admin/service/user_service.py

@@ -1,15 +1,10 @@
-import random
-
-from collections.abc import Sequence
 from typing import Any
 
 from fastapi import Request
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from backend.app.admin.crud.crud_dept import dept_dao
-from backend.app.admin.crud.crud_role import role_dao
 from backend.app.admin.crud.crud_user import user_dao
-from backend.app.admin.model import Role, User
+from backend.app.admin.model import User
 from backend.app.admin.schema.user import (
     AddUserParam,
     ResetPasswordParam,
@@ -18,15 +13,12 @@ from backend.app.admin.schema.user import (
 from backend.app.admin.schema.user_password_history import CreateUserPasswordHistoryParam
 from backend.app.admin.service.user_password_history_service import password_security_service
 from backend.app.admin.utils.password_security import password_verify, validate_new_password
-from backend.common.context import ctx
 from backend.common.enums import UserPermissionType
 from backend.common.exception import errors
 from backend.common.pagination import paging_data
-from backend.common.response.response_code import CustomErrorCode
 from backend.common.security.jwt import get_token, jwt_decode
 from backend.core.conf import settings
 from backend.database.redis import redis_client
-from backend.utils.serializers import select_join_serialize
 
 
 class UserService:
@@ -42,44 +34,24 @@ class UserService:
         :param username: 用户名
         :return:
         """
-        user = await user_dao.get_join(db, user_id=pk, username=username)
+        user = await user_dao.get(db, pk) if pk else await user_dao.get_by_username(db, username or '')
         if not user:
             raise errors.NotFoundError(msg='用户不存在')
         return user
 
     @staticmethod
-    async def get_roles(*, db: AsyncSession, pk: int) -> Sequence[Role]:
+    async def get_list(*, db: AsyncSession, username: str, phone: str, status: int) -> dict[str, Any]:
-        """
-        获取用户所有角色
-
-        :param db: 数据库会话
-        :param pk: 用户 ID
-        :return:
-        """
-        user = await user_dao.get_join(db, user_id=pk)
-        if not user:
-            raise errors.NotFoundError(msg='用户不存在')
-        return user.roles
-
-    @staticmethod
-    async def get_list(*, db: AsyncSession, dept: int, username: str, phone: str, status: int) -> dict[str, Any]:
         """
         获取用户列表
 
         :param db: 数据库会话
-        :param dept: 部门 ID
         :param username: 用户名
         :param phone: 手机号
         :param status: 状态
         :return:
         """
-        user_select = await user_dao.get_select(dept=dept, username=username, phone=phone, status=status)
+        user_select = await user_dao.get_select(username=username, phone=phone, status=status)
-        data = await paging_data(db, user_select)
+        return await paging_data(db, user_select)
-        if data['items']:
-            serialized_items = select_join_serialize(data['items'], relationships=['User-m2o-Dept', 'User-m2m-Role'])
-            # 确保返回的是列表，即使只有一个元素
-            data['items'] = [serialized_items] if not isinstance(serialized_items, list) else serialized_items
-        return data
 
     @staticmethod
     async def create(*, db: AsyncSession, obj: AddUserParam) -> None:
@@ -92,14 +64,11 @@ class UserService:
         """
         if await user_dao.get_by_username(db, obj.username):
             raise errors.ConflictError(msg='用户名已注册')
-        obj.nickname = obj.nickname or f'#{random.randrange(88888, 99999)}'
+        if obj.email and await user_dao.check_email(db, obj.email):
+            raise errors.ConflictError(msg='邮箱已被绑定')
         if not obj.password:
             raise errors.RequestError(msg='密码不允许为空')
-        if not await dept_dao.get(db, obj.dept_id):
+        obj.nickname = obj.nickname or obj.username
-            raise errors.NotFoundError(msg='部门不存在')
-        for role_id in obj.roles:
-            if not await role_dao.get(db, role_id):
-                raise errors.NotFoundError(msg='角色不存在')
         await user_dao.add(db, obj)
 
     @staticmethod
@@ -112,22 +81,21 @@ class UserService:
         :param obj: 用户更新参数
         :return:
         """
-        user = await user_dao.get_join(db, user_id=pk)
+        user = await user_dao.get(db, pk)
         if not user:
             raise errors.NotFoundError(msg='用户不存在')
         if obj.username != user.username and await user_dao.get_by_username(db, obj.username):
             raise errors.ConflictError(msg='用户名已注册')
-        if obj.dept_id and obj.dept_id != user.dept_id and not await dept_dao.get(db, dept_id=obj.dept_id):
+        if obj.email and obj.email != user.email:
-            raise errors.NotFoundError(msg='部门不存在')
+            email_user = await user_dao.check_email(db, obj.email)
-        for role_id in obj.roles:
+            if email_user:
-            if not await role_dao.get(db, role_id):
+                raise errors.ConflictError(msg='邮箱已被绑定')
-                raise errors.NotFoundError(msg='角色不存在')
         count = await user_dao.update(db, user.id, obj)
         await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{user.id}')
         return count
 
     @staticmethod
-    async def update_permission(*, db: AsyncSession, request: Request, pk: int, type: UserPermissionType) -> int:  # noqa: C901
+    async def update_permission(*, db: AsyncSession, request: Request, pk: int, type: UserPermissionType) -> int:  # ruff:ignore[complex-structure]
         """
         更新用户权限
 
@@ -144,7 +112,7 @@ class UserService:
                     raise errors.NotFoundError(msg='用户不存在')
                 if pk == request.user.id:
                     raise errors.ForbiddenError(msg='禁止修改自身权限')
-                count = await user_dao.set_super(db, pk, is_super=not user.status)
+                count = await user_dao.set_super(db, pk, is_super=not user.is_superuser)
             case UserPermissionType.staff:
                 user = await user_dao.get(db, pk)
                 if not user:
@@ -172,15 +140,15 @@ class UserService:
                     # 系统管理员修改自身时，除当前 token 外，其他 token 失效
                     if not new_multi_login:
                         key_prefix = f'{settings.TOKEN_REDIS_PREFIX}:{user.id}'
-                        await redis_client.delete_prefix(
+                        await redis_client.delete_by_prefix(
                             key_prefix,
-                            exclude=f'{key_prefix}:{token_payload.session_uuid}',
+                            exclude_keys=f'{key_prefix}:{token_payload.session_uuid}',
                         )
                 else:
                     # 系统管理员修改他人时，他人 token 全部失效
                     if not new_multi_login:
                         key_prefix = f'{settings.TOKEN_REDIS_PREFIX}:{user.id}'
-                        await redis_client.delete_prefix(key_prefix)
+                        await redis_client.delete_by_prefix(key_prefix)
             case _:
                 raise errors.RequestError(msg='权限类型不存在')
 
@@ -207,14 +175,9 @@ class UserService:
         history_obj = CreateUserPasswordHistoryParam(user_id=user.id, password=user.password)
         await password_security_service.save_password_history(db, history_obj)
         await user_dao.update_password_changed_time(db, user.id)
-
+        await redis_client.delete_by_prefix(f'{settings.TOKEN_REDIS_PREFIX}:{user.id}')
-        key_prefix = [
+        await redis_client.delete_by_prefix(f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{user.id}')
-            f'{settings.TOKEN_REDIS_PREFIX}:{user.id}',
+        await redis_client.delete_by_prefix(f'{settings.JWT_USER_REDIS_PREFIX}:{user.id}')
-            f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{user.id}',
-            f'{settings.JWT_USER_REDIS_PREFIX}:{user.id}',
-        ]
-        for prefix in key_prefix:
-            await redis_client.delete(prefix)
         return count
 
     @staticmethod
@@ -246,22 +209,18 @@ class UserService:
         return count
 
     @staticmethod
-    async def update_email(*, db: AsyncSession, user_id: int, captcha: str, email: str) -> int:
+    async def update_email(*, db: AsyncSession, user_id: int, email: str) -> int:
         """
         更新当前用户邮箱
 
         :param db: 数据库会话
         :param user_id: 用户 ID
-        :param captcha: 邮箱验证码
         :param email: 邮箱
         :return:
         """
-        captcha_code = await redis_client.get(f'{settings.EMAIL_CAPTCHA_REDIS_PREFIX}:{ctx.ip}')
+        email_user = await user_dao.check_email(db, email)
-        if not captcha_code:
+        if email_user and email_user.id != user_id:
-            raise errors.RequestError(msg='验证码已失效，请重新获取')
+            raise errors.ConflictError(msg='邮箱已被绑定')
-        if captcha != captcha_code:
-            raise errors.CustomError(error=CustomErrorCode.CAPTCHA_ERROR)
-        await redis_client.delete(f'{settings.EMAIL_CAPTCHA_REDIS_PREFIX}:{ctx.ip}')
         count = await user_dao.update_email(db, user_id, email)
         await redis_client.delete(f'{settings.JWT_USER_REDIS_PREFIX}:{user_id}')
         return count
@@ -290,14 +249,9 @@ class UserService:
         history_obj = CreateUserPasswordHistoryParam(user_id=user.id, password=user.password)
         await password_security_service.save_password_history(db, history_obj)
         await user_dao.update_password_changed_time(db, user.id)
-
+        await redis_client.delete_by_prefix(f'{settings.TOKEN_REDIS_PREFIX}:{user_id}')
-        key_prefix = [
+        await redis_client.delete_by_prefix(f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{user_id}')
-            f'{settings.TOKEN_REDIS_PREFIX}:{user_id}',
+        await redis_client.delete_by_prefix(f'{settings.JWT_USER_REDIS_PREFIX}:{user_id}')
-            f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{user_id}',
-            f'{settings.JWT_USER_REDIS_PREFIX}:{user_id}',
-        ]
-        for prefix in key_prefix:
-            await redis_client.delete_prefix(prefix)
         return count
 
     @staticmethod
@@ -313,12 +267,9 @@ class UserService:
         if not user:
             raise errors.NotFoundError(msg='用户不存在')
         count = await user_dao.delete(db, user.id)
-        key_prefix = [
+        await redis_client.delete_by_prefix(f'{settings.TOKEN_REDIS_PREFIX}:{user.id}')
-            f'{settings.TOKEN_REDIS_PREFIX}:{user.id}',
+        await redis_client.delete_by_prefix(f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{user.id}')
-            f'{settings.TOKEN_REFRESH_REDIS_PREFIX}:{user.id}',
+        await redis_client.delete_by_prefix(f'{settings.JWT_USER_REDIS_PREFIX}:{user.id}')
-        ]
-        for key in key_prefix:
-            await redis_client.delete_prefix(key)
         return count
 
 

backend/app/admin/tests/api_v1/test_auth.py

@@ -1,7 +0,0 @@
-from starlette.testclient import TestClient
-
-
-def test_logout(client: TestClient, token_headers: dict[str, str]) -> None:
-    response = client.post('/auth/logout', headers=token_headers)
-    assert response.status_code == 200
-    assert response.json()['code'] == 200

backend/app/admin/tests/utils/db.py

@@ -1,15 +0,0 @@
-from collections.abc import AsyncGenerator
-
-from sqlalchemy.ext.asyncio.session import AsyncSession
-
-from backend.database.db import create_async_engine_and_session, create_database_url
-
-TEST_SQLALCHEMY_DATABASE_URL = create_database_url(unittest=True)
-
-_, async_test_db_session = create_async_engine_and_session(TEST_SQLALCHEMY_DATABASE_URL)
-
-
-async def override_get_db() -> AsyncGenerator[AsyncSession, None]:
-    """session 生成器"""
-    async with async_test_db_session() as session:
-        yield session

backend/app/admin/utils/cache.py

@@ -1,9 +1,5 @@
 from collections.abc import Sequence
 
-from sqlalchemy import select
-from sqlalchemy.ext.asyncio import AsyncSession
-
-from backend.app.admin.model import data_scope_rule, role_data_scope, role_menu, user_role
 from backend.core.conf import settings
 from backend.database.redis import redis_client
 
@@ -13,86 +9,9 @@ class UserCacheManager:
 
     @staticmethod
     async def clear(user_ids: Sequence[int]) -> None:
-        """
+        """清理用户缓存"""
-        清理用户缓存
-
-        :param user_ids: 用户 ID 列表
-        :return:
-        """
         if user_ids:
             await redis_client.delete(*[f'{settings.JWT_USER_REDIS_PREFIX}:{user_id}' for user_id in user_ids])
 
-    async def clear_by_role_id(self, db: AsyncSession, role_ids: list[int]) -> None:
-        """
-        通过角色 ID 清理用户缓存
-
-        :param db: 数据库会话
-        :param role_ids: 角色 ID 列表
-        :return:
-        """
-        stmt = select(user_role.c.user_id).where(user_role.c.role_id.in_(role_ids)).distinct()
-        result = await db.execute(stmt)
-        user_ids = result.scalars().all()
-
-        await self.clear(user_ids)
-
-    async def clear_by_menu_id(self, db: AsyncSession, menu_ids: list[int]) -> None:
-        """
-        通过菜单 ID 清理用户缓存
-
-        :param db: 数据库会话
-        :param menu_ids: 菜单 ID 列表
-        :return:
-        """
-        stmt = (
-            select(user_role.c.user_id)
-            .join(role_menu, user_role.c.role_id == role_menu.c.role_id)
-            .where(role_menu.c.menu_id.in_(menu_ids))
-            .distinct()
-        )
-        result = await db.execute(stmt)
-        user_ids = result.scalars().all()
-
-        await self.clear(user_ids)
-
-    async def clear_by_data_scope_id(self, db: AsyncSession, scope_ids: list[int]) -> None:
-        """
-        通过数据范围 ID 清理用户缓存
-
-        :param db: 数据库会话
-        :param scope_ids: 数据范围 ID 列表
-        :return:
-        """
-        stmt = (
-            select(user_role.c.user_id)
-            .join(role_data_scope, user_role.c.role_id == role_data_scope.c.role_id)
-            .where(role_data_scope.c.data_scope_id.in_(scope_ids))
-            .distinct()
-        )
-        result = await db.execute(stmt)
-        user_ids = result.scalars().all()
-
-        await self.clear(user_ids)
-
-    async def clear_by_data_rule_id(self, db: AsyncSession, rule_ids: list[int]) -> None:
-        """
-        通过数据规则 ID 清理用户缓存
-
-        :param db: 数据库会话
-        :param rule_ids: 数据规则 ID 列表
-        :return:
-        """
-        stmt = (
-            select(user_role.c.user_id)
-            .join(role_data_scope, user_role.c.role_id == role_data_scope.c.role_id)
-            .join(data_scope_rule, role_data_scope.c.data_scope_id == data_scope_rule.c.data_scope_id)
-            .where(data_scope_rule.c.data_rule_id.in_(rule_ids))
-            .distinct()
-        )
-        result = await db.execute(stmt)
-        user_ids = result.scalars().all()
-
-        await self.clear(user_ids)
-
 
 user_cache_manager: UserCacheManager = UserCacheManager()

backend/app/admin/utils/password_security.py

@@ -6,7 +6,7 @@ from backend.app.admin.crud.crud_user_password_history import user_password_hist
 from backend.common.exception import errors
 from backend.core.conf import settings
 from backend.utils.dynamic_config import load_user_security_config
-from backend.utils.re_verify import is_has_letter, is_has_number, is_has_special_char
+from backend.utils.pattern_validate import is_has_letter, is_has_number, is_has_special_char
 
 password_hash = PasswordHash((BcryptHasher(),))
 

backend/app/router.py

@@ -1,9 +1,7 @@
 from fastapi import APIRouter
 
 from backend.app.admin.api.router import v1 as admin_v1
-from backend.app.task.api.router import v1 as task_v1
 
 router = APIRouter()
 
 router.include_router(admin_v1)
-router.include_router(task_v1)

backend/app/task/README.md

@@ -1,28 +0,0 @@
-## 任务介绍
-
-当前任务使用 Celery
-实现，实施方案请查看 [#225](https://github.com/fastapi-practices/fastapi_best_architecture/discussions/225)
-
-## 定时任务
-
-在 `backend/app/task/tasks/beat.py` 文件内编写相关定时任务
-
-### 简单任务
-
-在 `backend/app/task/tasks/tasks.py` 文件内编写相关任务代码
-
-### 层级任务
-
-如果你想对任务进行目录层级划分，使任务结构更加清晰，你可以新建任意目录，但必须注意的是
-
-1. 在 `backend/app/task/tasks` 目录下新建 python 包目录
-2. 新建目录后，务必更新 `conf.py` 配置中的 `CELERY_TASKS_PACKAGES`，将新建目录模块路径添加到此列表
-3. 在新建目录下，务必添加 `tasks.py` 文件，并在此文件中编写相关任务代码
-
-## 消息代理
-
-你可以通过 `CELERY_BROKER` 控制消息代理选择，它支持 redis 和 rabbitmq
-
-对于本地调试，建议使用 redis
-
-对于线上环境，强制使用 rabbitmq

backend/app/task/__init__.py

@@ -1,8 +0,0 @@
-import sys
-
-from backend.core.path_conf import BASE_PATH
-
-from .actions import *  # noqa: F403
-
-# 导入项目根目录
-sys.path.append(str(BASE_PATH.parent))

backend/app/task/actions.py

@@ -1,11 +0,0 @@
-from starlette.concurrency import run_in_threadpool
-
-from backend.app.task.celery import celery_app
-from backend.common.socketio.server import sio
-
-
-@sio.event
-async def task_worker_status(sid, data) -> None:  # noqa: ANN001
-    """任务 Worker 状态事件"""
-    worker = await run_in_threadpool(celery_app.control.ping)
-    await sio.emit('task_worker_status', worker, sid)

backend/app/task/api/router.py

@@ -1,12 +0,0 @@
-from fastapi import APIRouter
-
-from backend.app.task.api.v1.control import router as task_control_router
-from backend.app.task.api.v1.result import router as task_result_router
-from backend.app.task.api.v1.scheduler import router as task_scheduler_router
-from backend.core.conf import settings
-
-v1 = APIRouter(prefix=settings.FASTAPI_API_V1_PATH, tags=['任务'])
-
-v1.include_router(task_control_router, prefix='/tasks')
-v1.include_router(task_result_router, prefix='/task-results')
-v1.include_router(task_scheduler_router, prefix='/schedulers')

backend/app/task/api/v1/control.py

@@ -1,49 +0,0 @@
-from typing import Annotated
-
-from fastapi import APIRouter, Depends, Path
-from starlette.concurrency import run_in_threadpool
-
-from backend.app.task import celery_app
-from backend.app.task.schema.control import TaskRegisteredDetail
-from backend.common.exception import errors
-from backend.common.response.response_schema import ResponseModel, ResponseSchemaModel, response_base
-from backend.common.security.jwt import DependsJwtAuth
-from backend.common.security.permission import RequestPermission
-from backend.common.security.rbac import DependsRBAC
-
-router = APIRouter()
-
-
-@router.get('/registered', summary='获取已注册的任务', dependencies=[DependsJwtAuth])
-async def get_task_registered() -> ResponseSchemaModel[list[TaskRegisteredDetail]]:
-    inspector = celery_app.control.inspect(timeout=0.5)
-    registered = await run_in_threadpool(inspector.registered)
-    if not registered:
-        raise errors.ServerError(msg='Celery Worker 暂不可用，请稍后重试')
-    task_registered = []
-    celery_app_tasks = celery_app.tasks
-    for tasks in registered.values():
-        for task in tasks:
-            task_ins = celery_app_tasks.get(task)
-            if task_ins:
-                task_doc = task_ins.__doc__
-                task_registered.append({'name': task_doc or task_ins, 'task': task_ins})
-            else:
-                task_registered.append({'name': task, 'task': task})
-    return response_base.success(data=task_registered)
-
-
-@router.delete(
-    '/{task_id}/cancel',
-    summary='撤销任务',
-    dependencies=[
-        Depends(RequestPermission('sys:task:revoke')),
-        DependsRBAC,
-    ],
-)
-async def revoke_task(task_id: Annotated[str, Path(description='任务 UUID')]) -> ResponseModel:
-    workers = await run_in_threadpool(celery_app.control.ping, timeout=0.5)
-    if not workers:
-        raise errors.ServerError(msg='Celery Worker 暂不可用，请稍后重试')
-    celery_app.control.revoke(task_id)
-    return response_base.success()

backend/app/task/api/v1/result.py

@@ -1,55 +0,0 @@
-from typing import Annotated
-
-from fastapi import APIRouter, Depends, Path, Query
-
-from backend.app.task.schema.result import DeleteTaskResultParam, GetTaskResultDetail
-from backend.app.task.service.result_service import task_result_service
-from backend.common.pagination import DependsPagination, PageData
-from backend.common.response.response_schema import ResponseModel, ResponseSchemaModel, response_base
-from backend.common.security.jwt import DependsJwtAuth
-from backend.common.security.permission import RequestPermission
-from backend.common.security.rbac import DependsRBAC
-from backend.database.db import CurrentSession, CurrentSessionTransaction
-
-router = APIRouter()
-
-
-@router.get('/{pk}', summary='获取任务结果详情', dependencies=[DependsJwtAuth])
-async def get_task_result(
-    db: CurrentSession,
-    pk: Annotated[int, Path(description='任务结果 ID')],
-) -> ResponseSchemaModel[GetTaskResultDetail]:
-    result = await task_result_service.get(db=db, pk=pk)
-    return response_base.success(data=result)
-
-
-@router.get(
-    '',
-    summary='分页获取所有任务结果',
-    dependencies=[
-        DependsJwtAuth,
-        DependsPagination,
-    ],
-)
-async def get_task_results_paginated(
-    db: CurrentSession,
-    name: Annotated[str | None, Query(description='任务名称')] = None,
-    task_id: Annotated[str | None, Query(description='任务 ID')] = None,
-) -> ResponseSchemaModel[PageData[GetTaskResultDetail]]:
-    page_data = await task_result_service.get_list(db=db, name=name, task_id=task_id)
-    return response_base.success(data=page_data)
-
-
-@router.delete(
-    '',
-    summary='批量删除任务结果',
-    dependencies=[
-        Depends(RequestPermission('sys:task:del')),
-        DependsRBAC,
-    ],
-)
-async def delete_task_result(db: CurrentSessionTransaction, obj: DeleteTaskResultParam) -> ResponseModel:
-    count = await task_result_service.delete(db=db, obj=obj)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()

backend/app/task/api/v1/scheduler.py

@@ -1,129 +0,0 @@
-from typing import Annotated
-
-from fastapi import APIRouter, Depends, Path, Query
-
-from backend.app.task.schema.scheduler import (
-    CreateTaskSchedulerParam,
-    GetTaskSchedulerDetail,
-    UpdateTaskSchedulerParam,
-)
-from backend.app.task.service.scheduler_service import task_scheduler_service
-from backend.common.pagination import DependsPagination, PageData
-from backend.common.response.response_schema import ResponseModel, ResponseSchemaModel, response_base
-from backend.common.security.jwt import DependsJwtAuth
-from backend.common.security.permission import RequestPermission
-from backend.common.security.rbac import DependsRBAC
-from backend.database.db import CurrentSession, CurrentSessionTransaction
-
-router = APIRouter()
-
-
-@router.get('/all', summary='获取所有任务调度', dependencies=[DependsJwtAuth])
-async def get_all_task_schedulers(db: CurrentSession) -> ResponseSchemaModel[list[GetTaskSchedulerDetail]]:
-    schedulers = await task_scheduler_service.get_all(db=db)
-    return response_base.success(data=schedulers)
-
-
-@router.get('/{pk}', summary='获取任务调度详情', dependencies=[DependsJwtAuth])
-async def get_task_scheduler(
-    db: CurrentSession,
-    pk: Annotated[int, Path(description='任务调度 ID')],
-) -> ResponseSchemaModel[GetTaskSchedulerDetail]:
-    task_scheduler = await task_scheduler_service.get(db=db, pk=pk)
-    return response_base.success(data=task_scheduler)
-
-
-@router.get(
-    '',
-    summary='分页获取所有任务调度',
-    dependencies=[
-        DependsJwtAuth,
-        DependsPagination,
-    ],
-)
-async def get_task_scheduler_paginated(
-    db: CurrentSession,
-    name: Annotated[int | None, Path(description='任务调度名称')] = None,
-    type: Annotated[int | None, Query(description='任务调度类型')] = None,
-) -> ResponseSchemaModel[PageData[GetTaskSchedulerDetail]]:
-    page_data = await task_scheduler_service.get_list(db=db, name=name, type=type)
-    return response_base.success(data=page_data)
-
-
-@router.post(
-    '',
-    summary='创建任务调度',
-    dependencies=[
-        Depends(RequestPermission('sys:task:add')),
-        DependsRBAC,
-    ],
-)
-async def create_task_scheduler(db: CurrentSessionTransaction, obj: CreateTaskSchedulerParam) -> ResponseModel:
-    await task_scheduler_service.create(db=db, obj=obj)
-    return response_base.success()
-
-
-@router.put(
-    '/{pk}',
-    summary='更新任务调度',
-    dependencies=[
-        Depends(RequestPermission('sys:task:edit')),
-        DependsRBAC,
-    ],
-)
-async def update_task_scheduler(
-    db: CurrentSessionTransaction,
-    pk: Annotated[int, Path(description='任务调度 ID')],
-    obj: UpdateTaskSchedulerParam,
-) -> ResponseModel:
-    count = await task_scheduler_service.update(db=db, pk=pk, obj=obj)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()
-
-
-@router.put(
-    '/{pk}/status',
-    summary='更新任务调度状态',
-    dependencies=[
-        Depends(RequestPermission('sys:task:edit')),
-        DependsRBAC,
-    ],
-)
-async def update_task_scheduler_status(
-    db: CurrentSessionTransaction, pk: Annotated[int, Path(description='任务调度 ID')]
-) -> ResponseModel:
-    count = await task_scheduler_service.update_status(db=db, pk=pk)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()
-
-
-@router.delete(
-    '/{pk}',
-    summary='删除任务调度',
-    dependencies=[
-        Depends(RequestPermission('sys:task:del')),
-        DependsRBAC,
-    ],
-)
-async def delete_task_scheduler(
-    db: CurrentSessionTransaction, pk: Annotated[int, Path(description='任务调度 ID')]
-) -> ResponseModel:
-    count = await task_scheduler_service.delete(db=db, pk=pk)
-    if count > 0:
-        return response_base.success()
-    return response_base.fail()
-
-
-@router.post(
-    '/{pk}/execute',
-    summary='执行任务',
-    dependencies=[
-        Depends(RequestPermission('sys:task:exec')),
-        DependsRBAC,
-    ],
-)
-async def execute_task(db: CurrentSession, pk: Annotated[int, Path(description='任务调度 ID')]) -> ResponseModel:
-    await task_scheduler_service.execute(db=db, pk=pk)
-    return response_base.success()

backend/app/task/celery.py

@@ -1,68 +0,0 @@
-import os
-
-import celery
-import celery_aio_pool
-
-from backend.app.task.tasks.beat import LOCAL_BEAT_SCHEDULE
-from backend.core.conf import settings
-from backend.core.path_conf import BASE_PATH
-
-
-def find_task_packages() -> list[str]:
-    packages = []
-    task_dir = BASE_PATH / 'app' / 'task' / 'tasks'
-    for root, _dirs, files in os.walk(task_dir):
-        if 'tasks.py' in files:
-            package = root.replace(str(BASE_PATH.parent) + os.path.sep, '').replace(os.path.sep, '.')
-            packages.append(package)
-    return packages
-
-
-def init_celery() -> celery.Celery:
-    """初始化 Celery 应用"""
-
-    # TODO: Update this work if celery version >= 6.0.0
-    # https://github.com/fastapi-practices/fastapi_best_architecture/issues/321
-    # https://github.com/celery/celery/issues/7874
-    celery.app.trace.build_tracer = celery_aio_pool.build_async_tracer
-    celery.app.trace.reset_worker_optimizations()
-
-    broker_url = f'amqp://{settings.CELERY_RABBITMQ_USERNAME}:{settings.CELERY_RABBITMQ_PASSWORD}@{settings.CELERY_RABBITMQ_HOST}:{settings.CELERY_RABBITMQ_PORT}/{settings.CELERY_RABBITMQ_VHOST}'
-    if settings.CELERY_BROKER == 'redis':
-        broker_url = f'redis://:{settings.REDIS_PASSWORD}@{settings.REDIS_HOST}:{settings.REDIS_PORT}/{settings.CELERY_BROKER_REDIS_DATABASE}'
-
-    result_backend = f'db+postgresql+psycopg://{settings.DATABASE_USER}:{settings.DATABASE_PASSWORD}@{settings.DATABASE_HOST}:{settings.DATABASE_PORT}/{settings.DATABASE_SCHEMA}'
-    if settings.DATABASE_TYPE == 'mysql':
-        result_backend = result_backend.replace('postgresql+psycopg', 'mysql+pymysql')
-
-    # https://docs.celeryq.dev/en/stable/userguide/configuration.html
-    app = celery.Celery(
-        'fba_celery',
-        broker_url=broker_url,
-        broker_connection_retry_on_startup=True,
-        result_backend=result_backend,
-        result_extended=True,
-        database_engine_options={'echo': settings.DATABASE_ECHO},
-        # result_expires=0,
-        # beat_sync_every=1,
-        beat_schedule=LOCAL_BEAT_SCHEDULE,
-        beat_scheduler='backend.app.task.utils.schedulers:DatabaseScheduler',
-        task_cls='backend.app.task.tasks.base:TaskBase',
-        task_track_started=True,
-        enable_utc=False,
-        timezone=settings.DATETIME_TIMEZONE,
-    )
-
-    # 在 Celery 中设置此参数无效
-    # 参数：https://github.com/celery/celery/issues/7270
-    app.loader.override_backends = {'db': 'backend.app.task.database:DatabaseBackend'}
-
-    # 自动发现任务
-    packages = find_task_packages()
-    app.autodiscover_tasks(packages)
-
-    return app
-
-
-# 创建 Celery 实例
-celery_app: celery.Celery = init_celery()

backend/app/task/crud/crud_result.py

@@ -1,49 +0,0 @@
-from sqlalchemy import Select
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy_crud_plus import CRUDPlus
-
-from backend.app.task.model import TaskResult
-
-
-class CRUDTaskResult(CRUDPlus[TaskResult]):
-    """任务结果数据库操作类"""
-
-    async def get(self, db: AsyncSession, pk: int) -> TaskResult | None:
-        """
-        获取任务结果详情
-
-        :param db: 数据库会话
-        :param pk: 任务 ID
-        :return:
-        """
-        return await self.select_model(db, pk)
-
-    async def get_select(self, name: str | None, task_id: str | None) -> Select:
-        """
-        获取任务结果列表查询表达式
-
-        :param name: 任务名称
-        :param task_id: 任务 ID
-        :return:
-        """
-        filters = {}
-
-        if name is not None:
-            filters['name__like'] = f'%{name}%'
-        if task_id is not None:
-            filters['task_id'] = task_id
-
-        return await self.select_order('id', 'desc', **filters)
-
-    async def delete(self, db: AsyncSession, pks: list[int]) -> int:
-        """
-        批量删除任务结果
-
-        :param db: 数据库会话
-        :param pks: 任务结果 ID 列表
-        :return:
-        """
-        return await self.delete_model_by_column(db, allow_multiple=True, id__in=pks)
-
-
-task_result_dao: CRUDTaskResult = CRUDTaskResult(TaskResult)

backend/app/task/crud/crud_scheduler.py

@@ -1,115 +0,0 @@
-from collections.abc import Sequence
-
-from sqlalchemy import Select
-from sqlalchemy.ext.asyncio import AsyncSession
-from sqlalchemy_crud_plus import CRUDPlus
-
-from backend.app.task.model import TaskScheduler
-from backend.app.task.schema.scheduler import CreateTaskSchedulerParam, UpdateTaskSchedulerParam
-
-
-class CRUDTaskScheduler(CRUDPlus[TaskScheduler]):
-    """任务调度数据库操作类"""
-
-    @staticmethod
-    async def get(db: AsyncSession, pk: int) -> TaskScheduler | None:
-        """
-        获取任务调度
-
-        :param db: 数据库会话
-        :param pk: 任务调度 ID
-        :return:
-        """
-        return await task_scheduler_dao.select_model(db, pk)
-
-    async def get_all(self, db: AsyncSession) -> Sequence[TaskScheduler]:
-        """
-        获取所有任务调度
-
-        :param db: 数据库会话
-        :return:
-        """
-        return await self.select_models(db)
-
-    async def get_select(self, name: str | None, type: int | None) -> Select:
-        """
-        获取任务调度列表查询表达式
-
-        :param name: 任务调度名称
-        :param type: 任务调度类型
-        :return:
-        """
-        filters = {}
-
-        if name is not None:
-            filters['name__like'] = f'%{name}%'
-        if type is not None:
-            filters['type'] = type
-
-        return await self.select_order('id', **filters)
-
-    async def get_by_name(self, db: AsyncSession, name: str) -> TaskScheduler | None:
-        """
-        通过名称获取任务调度
-
-        :param db: 数据库会话
-        :param name: 任务调度名称
-        :return:
-        """
-        return await self.select_model_by_column(db, name=name)
-
-    async def create(self, db: AsyncSession, obj: CreateTaskSchedulerParam) -> None:
-        """
-        创建任务调度
-
-        :param db: 数据库会话
-        :param obj: 创建任务调度参数
-        :return:
-        """
-        await self.create_model(db, obj, flush=True)
-        TaskScheduler.no_changes = False
-
-    async def update(self, db: AsyncSession, pk: int, obj: UpdateTaskSchedulerParam) -> int:
-        """
-        更新任务调度
-
-        :param db: 数据库会话
-        :param pk: 任务调度 ID
-        :param obj: 更新任务调度参数
-        :return:
-        """
-        task_scheduler = await self.get(db, pk)
-        for key, value in obj.model_dump(exclude_unset=True).items():
-            setattr(task_scheduler, key, value)
-        TaskScheduler.no_changes = False
-        return 1
-
-    async def set_status(self, db: AsyncSession, pk: int, *, status: bool) -> int:
-        """
-        设置任务调度状态
-
-        :param db: 数据库会话
-        :param pk: 任务调度 ID
-        :param status: 状态
-        :return:
-        """
-        task_scheduler = await self.get(db, pk)
-        task_scheduler.enabled = status
-        TaskScheduler.no_changes = False
-        return 1
-
-    async def delete(self, db: AsyncSession, pk: int) -> int:
-        """
-        删除任务调度
-
-        :param db: 数据库会话
-        :param pk: 任务调度 ID
-        :return:
-        """
-        task_scheduler = await self.get(db, pk)
-        await db.delete(task_scheduler)
-        TaskScheduler.no_changes = False
-        return 1
-
-
-task_scheduler_dao: CRUDTaskScheduler = CRUDTaskScheduler(TaskScheduler)

backend/app/task/database.py

@@ -1,178 +0,0 @@
-from celery import states
-from celery.backends.base import BaseBackend
-from celery.backends.database import retry, session_cleanup
-from celery.exceptions import ImproperlyConfigured
-from celery.utils.time import maybe_timedelta
-from sqlalchemy import PickleType
-from sqlalchemy.orm import Session
-
-from backend.app.task.model.result import Task, TaskExtended, TaskSet
-from backend.app.task.session import SessionManager
-
-"""
-重写 from celery.backends.database 内部 DatabaseBackend 类，此类实现与模型配合不佳，导致 fba 创建表和 alembic 迁移困难
-"""
-
-
-class DatabaseBackend(BaseBackend):
-    """The database result backend."""
-
-    # ResultSet.iterate should sleep this much between each pool,
-    # to not bombard the database with queries.
-    subpolling_interval = 0.5
-
-    task_cls = Task
-    taskset_cls = TaskSet
-
-    def __init__(self, dburi=None, engine_options=None, url=None, **kwargs) -> None:  # noqa: ANN001
-        # The `url` argument was added later and is used by
-        # the app to set backend by url (celery.app.backends.by_url)
-        super().__init__(expires_type=maybe_timedelta, url=url, **kwargs)
-        conf = self.app.conf
-
-        if self.extended_result:
-            self.task_cls = TaskExtended
-
-        self.url = url or dburi or conf.database_url
-        self.engine_options = dict(engine_options or {}, **conf.database_engine_options or {})
-        self.short_lived_sessions = kwargs.get('short_lived_sessions', conf.database_short_lived_sessions)
-
-        schemas = conf.database_table_schemas or {}
-        tablenames = conf.database_table_names or {}
-        self.task_cls.configure(schema=schemas.get('task'), name=tablenames.get('task'))
-        self.taskset_cls.configure(schema=schemas.get('group'), name=tablenames.get('group'))
-
-        if not self.url:
-            raise ImproperlyConfigured(
-                'Missing connection string! Do you have the database_url setting set to a real value?',
-            )
-
-        self.session_manager = SessionManager()
-
-        create_tables_at_setup = conf.database_create_tables_at_setup
-        if create_tables_at_setup is True:
-            self._create_tables()
-
-    @property
-    def extended_result(self):  # noqa: ANN201
-        return self.app.conf.find_value_for_key('extended', 'result')
-
-    def _create_tables(self) -> None:
-        """Create the task and taskset tables."""
-        self.result_session()
-
-    def result_session(self, session_manager=None) -> Session:  # noqa: ANN001
-        if session_manager is None:
-            session_manager = self.session_manager
-        return session_manager.session_factory(
-            dburi=self.url,
-            short_lived_sessions=self.short_lived_sessions,
-            **self.engine_options,
-        )
-
-    @retry
-    def _store_result(self, task_id, result, state, traceback=None, request=None, **kwargs) -> None:  # noqa: ANN001
-        """Store return value and state of an executed task."""
-        session = self.result_session()
-        with session_cleanup(session):
-            task = list(session.query(self.task_cls).filter(self.task_cls.task_id == task_id))
-            task = task and task[0]
-            if not task:
-                task = self.task_cls(task_id)
-                task.task_id = task_id
-                session.add(task)
-                session.flush()
-
-            self._update_result(task, result, state, traceback=traceback, request=request)
-            session.commit()
-
-    def _update_result(self, task, result, state, traceback=None, request=None) -> None:  # noqa: ANN001
-        meta = self._get_result_meta(
-            result=result,
-            state=state,
-            traceback=traceback,
-            request=request,
-            format_date=False,
-            encode=True,
-        )
-
-        # Exclude the primary key id and task_id columns
-        # as we should not set it None
-        columns = [column.name for column in self.task_cls.__table__.columns if column.name not in {'id', 'task_id'}]
-
-        # Iterate through the columns name of the table
-        # to set the value from meta.
-        # If the value is not present in meta, set None
-        for column in columns:
-            value = meta.get(column)
-            setattr(task, column, value)
-
-    @retry
-    def _get_task_meta_for(self, task_id: str):  # noqa: ANN202
-        """Get task meta-data for a task by id."""
-        session = self.result_session()
-        with session_cleanup(session):
-            task = list(session.query(self.task_cls).filter(self.task_cls.task_id == task_id))
-            task = task and task[0]
-            if not task:
-                task = self.task_cls(task_id)
-                task.status = states.PENDING
-                task.result = None
-            data = task.to_dict()
-            if data.get('args', None) is not None:
-                data['args'] = self.decode(data['args'])
-            if data.get('kwargs', None) is not None:
-                data['kwargs'] = self.decode(data['kwargs'])
-            return self.meta_from_decoded(data)
-
-    @retry
-    def _save_group(self, group_id: str, result: PickleType):  # noqa: ANN202
-        """Store the result of an executed group."""
-        session = self.result_session()
-        with session_cleanup(session):
-            group = self.taskset_cls(group_id, result)
-            session.add(group)
-            session.flush()
-            session.commit()
-            return result
-
-    @retry
-    def _restore_group(self, group_id: str) -> dict | None:
-        """Get meta-data for group by id."""
-        session = self.result_session()
-        with session_cleanup(session):
-            group = session.query(self.taskset_cls).filter(self.taskset_cls.taskset_id == group_id).first()
-            if group:
-                return group.to_dict()
-
-    @retry
-    def _delete_group(self, group_id: str) -> None:
-        """Delete meta-data for group by id."""
-        session = self.result_session()
-        with session_cleanup(session):
-            session.query(self.taskset_cls).filter(self.taskset_cls.taskset_id == group_id).delete()
-            session.flush()
-            session.commit()
-
-    @retry
-    def _forget(self, task_id: str) -> None:
-        """Forget about result."""
-        session = self.result_session()
-        with session_cleanup(session):
-            session.query(self.task_cls).filter(self.task_cls.task_id == task_id).delete()
-            session.commit()
-
-    def cleanup(self) -> None:
-        """Delete expired meta-data."""
-        session = self.result_session()
-        expires = self.expires
-        now = self.app.now()
-        with session_cleanup(session):
-            session.query(self.task_cls).filter(self.task_cls.date_done < (now - expires)).delete()
-            session.query(self.taskset_cls).filter(self.taskset_cls.date_done < (now - expires)).delete()
-            session.commit()
-
-    def __reduce__(self, args=(), kwargs=None):  # noqa: ANN001, ANN204
-        kwargs = kwargs or {}
-        kwargs.update({'dburi': self.url, 'expires': self.expires, 'engine_options': self.engine_options})
-        return super().__reduce__(args, kwargs)

backend/app/task/enums.py

@@ -1,18 +0,0 @@
-from backend.common.enums import IntEnum, StrEnum
-
-
-class TaskSchedulerType(IntEnum):
-    """任务调度类型"""
-
-    INTERVAL = 0
-    CRONTAB = 1
-
-
-class PeriodType(StrEnum):
-    """周期类型"""
-
-    DAYS = 'days'
-    HOURS = 'hours'
-    MINUTES = 'minutes'
-    SECONDS = 'seconds'
-    MICROSECONDS = 'microseconds'

backend/app/task/model/__init__.py

@@ -1,2 +0,0 @@
-from backend.app.task.model.result import TaskExtended as TaskResult  # noqa: F401
-from backend.app.task.model.scheduler import TaskScheduler as TaskScheduler

backend/app/task/model/result.py

@@ -1,109 +0,0 @@
-import sqlalchemy as sa
-
-from celery import states
-from sqlalchemy.types import PickleType
-
-from backend.common.model import MappedBase, TimeZone
-from backend.utils.timezone import timezone
-
-"""
-重写 celery.backends.database.models 内部所有模型，适配 fba 创建表和 alembic 迁移
-"""
-
-
-class Task(MappedBase):
-    """Task result/status."""
-
-    __tablename__ = 'task_result'
-    __table_args__ = {'comment': '任务结果表'}
-
-    id = sa.Column(sa.Integer, sa.Sequence('task_id_sequence'), primary_key=True, autoincrement=True)
-    task_id = sa.Column(sa.String(155), unique=True)
-    status = sa.Column(sa.String(64), default=states.PENDING)
-    result = sa.Column(PickleType, nullable=True)
-    date_done = sa.Column(
-        TimeZone,
-        default=timezone.now,
-        onupdate=timezone.now,
-        nullable=True,
-    )
-    traceback = sa.Column(sa.Text, nullable=True)
-
-    def __init__(self, task_id: str) -> None:
-        self.task_id = task_id
-
-    def to_dict(self) -> dict:
-        return {
-            'task_id': self.task_id,
-            'status': self.status,
-            'result': self.result,
-            'traceback': self.traceback,
-            'date_done': self.date_done,
-        }
-
-    def __repr__(self) -> str:
-        return f'<Task {self.task_id} state: {self.status}>'
-
-    @classmethod
-    def configure(cls, schema=None, name=None) -> None:  # noqa: ANN001
-        cls.__table__.schema = schema
-        cls.id.default.schema = schema
-        cls.__table__.name = name or cls.__tablename__
-
-
-class TaskExtended(Task):
-    """For the extend result."""
-
-    __tablename__ = 'task_result'
-    __table_args__ = {'extend_existing': True, 'comment': '任务结果表'}
-
-    name = sa.Column(sa.String(155), nullable=True)
-    args = sa.Column(sa.LargeBinary, nullable=True)
-    kwargs = sa.Column(sa.LargeBinary, nullable=True)
-    worker = sa.Column(sa.String(155), nullable=True)
-    retries = sa.Column(sa.Integer, nullable=True)
-    queue = sa.Column(sa.String(155), nullable=True)
-
-    def to_dict(self) -> dict:
-        task_dict = super().to_dict()
-        task_dict.update({
-            'name': self.name,
-            'args': self.args,
-            'kwargs': self.kwargs,
-            'worker': self.worker,
-            'retries': self.retries,
-            'queue': self.queue,
-        })
-        return task_dict
-
-
-class TaskSet(MappedBase):
-    """TaskSet result."""
-
-    __tablename__ = 'task_set_result'
-    __table_args__ = {'comment': '任务集结果表'}
-
-    id = sa.Column(sa.Integer, sa.Sequence('taskset_id_sequence'), autoincrement=True, primary_key=True)
-    taskset_id = sa.Column(sa.String(155), unique=True)
-    result = sa.Column(PickleType, nullable=True)
-    date_done = sa.Column(TimeZone, default=timezone.now, nullable=True)
-
-    def __init__(self, taskset_id, result) -> None:  # noqa: ANN001
-        self.taskset_id = taskset_id
-        self.result = result
-
-    def to_dict(self) -> dict:
-        return {
-            'taskset_id': self.taskset_id,
-            'result': self.result,
-            'date_done': self.date_done,
-        }
-
-    def __repr__(self) -> str:
-        return f'<TaskSet: {self.taskset_id}>'
-
-    @classmethod
-    def configure(cls, schema=None, name=None) -> None:  # noqa: ANN001
-        cls.__table__.schema = schema
-        cls.id.default.schema = schema
-        cls.__table__.name = name or cls.__tablename__

backend/app/task/model/scheduler.py

@@ -1,70 +0,0 @@
-import asyncio
-
-from datetime import datetime
-
-import sqlalchemy as sa
-
-from sqlalchemy import event
-from sqlalchemy.orm import Mapped, mapped_column
-
-from backend.common.exception import errors
-from backend.common.model import Base, TimeZone, UniversalText, id_key
-from backend.core.conf import settings
-from backend.database.redis import redis_client
-from backend.utils.timezone import timezone
-
-
-class TaskScheduler(Base):
-    """任务调度表"""
-
-    __tablename__ = 'task_scheduler'
-
-    id: Mapped[id_key] = mapped_column(init=False)
-    name: Mapped[str] = mapped_column(sa.String(64), unique=True, comment='任务名称')
-    task: Mapped[str] = mapped_column(sa.String(256), comment='要运行的 Celery 任务')
-    args: Mapped[str | None] = mapped_column(sa.JSON(), comment='任务可接收的位置参数')
-    kwargs: Mapped[str | None] = mapped_column(sa.JSON(), comment='任务可接收的关键字参数')
-    queue: Mapped[str | None] = mapped_column(sa.String(256), comment='CELERY_TASK_QUEUES 中定义的队列')
-    exchange: Mapped[str | None] = mapped_column(sa.String(256), comment='低级别 AMQP 路由的交换机')
-    routing_key: Mapped[str | None] = mapped_column(sa.String(256), comment='低级别 AMQP 路由的路由密钥')
-    start_time: Mapped[datetime | None] = mapped_column(TimeZone, comment='任务开始触发的时间')
-    expire_time: Mapped[datetime | None] = mapped_column(TimeZone, comment='任务不再触发的截止时间')
-    expire_seconds: Mapped[int | None] = mapped_column(comment='任务不再触发的秒数时间差')
-    type: Mapped[int] = mapped_column(comment='调度类型（0间隔 1定时）')
-    interval_every: Mapped[int | None] = mapped_column(comment='任务再次运行前的间隔周期数')
-    interval_period: Mapped[str | None] = mapped_column(sa.String(256), comment='任务运行之间的周期类型')
-    crontab: Mapped[str | None] = mapped_column(sa.String(64), default='* * * * *', comment='任务运行的 Crontab 计划')
-    one_off: Mapped[bool] = mapped_column(default=False, comment='是否仅运行一次')
-    enabled: Mapped[bool] = mapped_column(default=True, comment='是否启用任务')
-    total_run_count: Mapped[int] = mapped_column(default=0, comment='任务触发的总次数')
-    last_run_time: Mapped[datetime | None] = mapped_column(TimeZone, default=None, comment='任务最后触发的时间')
-    remark: Mapped[str | None] = mapped_column(UniversalText, default=None, comment='备注')
-
-    no_changes: bool = False
-
-    @staticmethod
-    def before_insert_or_update(mapper, connection, target) -> None:  # noqa: ANN001
-        if target.expire_seconds is not None and target.expire_time:
-            raise errors.ConflictError(msg='expires 和 expire_seconds 只能设置一个')
-
-    @classmethod
-    def changed(cls, mapper, connection, target) -> None:  # noqa: ANN001
-        if not target.no_changes:
-            cls.update_changed(mapper, connection, target)
-
-    @classmethod
-    async def update_changed_async(cls) -> None:
-        now = timezone.now()
-        await redis_client.set(f'{settings.CELERY_REDIS_PREFIX}:last_update', timezone.to_str(now))
-
-    @classmethod
-    def update_changed(cls, mapper, connection, target) -> None:  # noqa: ANN001
-        asyncio.create_task(cls.update_changed_async())
-
-
-# 事件监听器
-event.listen(TaskScheduler, 'before_insert', TaskScheduler.before_insert_or_update)
-event.listen(TaskScheduler, 'before_update', TaskScheduler.before_insert_or_update)
-event.listen(TaskScheduler, 'after_insert', TaskScheduler.update_changed)
-event.listen(TaskScheduler, 'after_delete', TaskScheduler.update_changed)
-event.listen(TaskScheduler, 'after_update', TaskScheduler.changed)