Merge pull request #4496 from wikrin/v2

修复系统配置和用户配置接口无法正常工作的问题。

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -9,8 +9,9 @@ body:
         请确认以下信息：
         1. 请按此模板提交issues，不按模板提交的问题将直接关闭。
         2. 如果你的问题可以直接在以往 issue 或者 Telegram频道 中找到，那么你的 issue 将会被直接关闭。
-        3. 提交问题务必描述清楚、附上日志，描述不清导致无法理解和分析的问题会被直接关闭。
+        3. **$\color{red}{提交问题务必描述清楚、附上日志}$**，描述不清导致无法理解和分析的问题会被直接关闭。
         4. 此仓库为后端仓库，如果是前端 WebUI 问题请在[前端仓库](https://github.com/jxxghp/MoviePilot-Frontend)提 issue。
+        5. **$\color{red}{不要通过issues来寻求解决你的环境问题、配置安装类问题、咨询类问题}$**，否则直接关闭并加入用户 $\color{red}{黑名单}$ !实在没有精力陪一波又一波的伸手党玩。
   - type: checkboxes
     id: ensure
     attributes:
@@ -32,6 +33,16 @@ body:
       description: 遇到问题时程序所在的版本号
     validations:
       required: true
+  - type: dropdown
+    id: environment
+    attributes:
+      label: 运行环境
+      description: 当前程序运行环境
+      options:
+        - Docker
+        - Windows
+    validations:
+      required: true
   - type: dropdown
     id: type
     attributes:
@@ -40,7 +51,6 @@ body:
       options:
         - 主程序运行问题
         - 插件问题
-        - Docker或运行环境问题
         - 其他问题
     validations:
       required: true

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -14,6 +14,16 @@ body:
       description: 目前使用的程序版本
     validations:
       required: true
+  - type: dropdown
+    id: environment
+    attributes:
+      label: 运行环境
+      description: 当前程序运行环境
+      options:
+        - Docker
+        - Windows
+    validations:
+      required: true
   - type: dropdown
     id: type
     attributes:
@@ -22,7 +32,6 @@ body:
       options:
         - 主程序
         - 插件
-        - Docker
         - 其他
     validations:
       required: true

.github/ISSUE_TEMPLATE/rfc.yml

@@ -0,0 +1,45 @@
+name: 功能提案
+description: Request for Comments
+title: "[RFC]"
+labels: ["RFC"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        一份提案(RFC)定位为 **「在某功能/重构的具体开发前，用于开发者间 review 技术设计/方案的文档」**，
+        目的是让协作的开发者间清晰的知道「要做什么」和「具体会怎么做」，以及所有的开发者都能公开透明的参与讨论；
+        以便评估和讨论产生的影响 (遗漏的考虑、向后兼容性、与现有功能的冲突)，
+        因此提案侧重在对解决问题的 **方案、设计、步骤** 的描述上。
+          
+        如果仅希望讨论是否添加或改进某功能本身，请使用 -> [Issue: 功能改进](https://github.com/jxxghp/MoviePilot/issues/new?assignees=&labels=feature+request&projects=&template=feature_request.yml&title=%5BFeature+Request%5D%3A+)
+  - type: textarea
+    id: background
+    attributes:
+      label: 背景 or 问题
+      description: 简单描述遇到的什么问题或需要改动什么。可以引用其他 issue、讨论、文档等。
+    validations:
+      required: true
+  - type: textarea
+    id: goal
+    attributes:
+      label: "目标 & 方案简述"
+      description: 简单描述提案此提案实现后，**预期的目标效果**，以及简单大致描述会采取的方案/步骤，可能会/不会产生什么影响。
+    validations:
+      required: true
+  - type: textarea
+    id: design
+    attributes:
+      label: "方案设计 & 实现步骤"
+      description: |
+        详细描述你设计的具体方案，可以考虑拆分列表或要点，一步步描述具体打算如何实现的步骤和相关细节。
+        这部份不需要一次性写完整，即使在创建完此提案 issue 后，依旧可以再次编辑修改。
+    validations:
+      required: false
+  - type: textarea
+    id: alternative
+    attributes:
+      label: "替代方案 & 对比"
+      description: |
+        [可选] 为来实现目标效果，还考虑过什么其他方案，有什么对比？
+    validations:
+      required: false

.github/workflows/build.yml

@@ -1,66 +1,97 @@
-name: MoviePilot Builder
+name: MoviePilot Builder v2
 on:
   workflow_dispatch:
   push:
     branches:
-      - main
+      - v2
     paths:
-      - version.py
+      - 'version.py'
 
 jobs:
-  build:
+  Docker-build:
     runs-on: ubuntu-latest
     name: Build Docker Image
     steps:
-      -
-        name: Checkout
+      - name: Checkout
         uses: actions/checkout@v4
 
-      -
-        name: Release version
+      - name: Release version
         id: release_version
         run: |
           app_version=$(cat version.py |sed -ne "s/APP_VERSION\s=\s'v\(.*\)'/\1/gp")
           echo "app_version=$app_version" >> $GITHUB_ENV
 
-      - 
-        name: Docker meta
+      - name: Docker Meta
         id: meta
         uses: docker/metadata-action@v5
         with:
-          images: ${{ secrets.DOCKER_USERNAME }}/moviepilot
+          images: |
+            ${{ secrets.DOCKER_USERNAME }}/moviepilot-v2
+            ghcr.io/${{ github.repository }}
           tags: |
             type=raw,value=${{ env.app_version }}
             type=raw,value=latest
 
-      -
-        name: Set Up QEMU
+      - name: Set Up QEMU
         uses: docker/setup-qemu-action@v3
 
-      -
-        name: Set Up Buildx
+      - name: Set Up Buildx
         uses: docker/setup-buildx-action@v3
 
-      -
-        name: Login DockerHub
+      - name: Login DockerHub
         uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
-      -
-        name: Build Image
+      - name: Login GitHub Container Registry
+        uses: docker/login-action@v3
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Build Image
         uses: docker/build-push-action@v5
         with:
           context: .
-          file: Dockerfile
+          file: docker/Dockerfile
           platforms: |
             linux/amd64
             linux/arm64/v8
           push: true
-          build-args: |
-            MOVIEPILOT_VERSION=${{ env.app_version }}
           tags: ${{ steps.meta.outputs.tags }}
           labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=gha, scope=${{ github.workflow }}
-          cache-to: type=gha, scope=${{ github.workflow }}
+          cache-from: type=gha, scope=${{ github.workflow }}-docker
+          cache-to: type=gha, scope=${{ github.workflow }}-docker
+
+      - name: Get existing release body
+        id: get_release_body
+        continue-on-error: true
+        run: |
+          release_body=$(curl -s -H "Authorization: token ${{ secrets.GITHUB_TOKEN }}" \
+            "https://api.github.com/repos/${{ github.repository }}/releases/tags/v${{ env.app_version }}" | \
+            jq -r '.body // ""')
+          echo "RELEASE_BODY<<EOF" >> $GITHUB_ENV
+          echo "$release_body" >> $GITHUB_ENV
+          echo "EOF" >> $GITHUB_ENV
+
+      - name: Delete Release
+        uses: dev-drprasad/delete-tag-and-release@v1.1
+        continue-on-error: true
+        with:
+          tag_name: v${{ env.app_version }}
+          delete_release: true
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Generate Release
+        uses: softprops/action-gh-release@v2
+        with:
+          tag_name: v${{ env.app_version }}
+          name: v${{ env.app_version }}
+          body: ${{ env.RELEASE_BODY }}
+          draft: false
+          prerelease: false
+          make_latest: false
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/issues.yml

@@ -0,0 +1,32 @@
+name: Close inactive issues
+on:
+ workflow_dispatch:
+
+ schedule:
+   # Github Action 只支持 UTC 时间。
+   # '0 18 * * *' 对应 UTC 时间的 18:00，也就是中国时区 (UTC+8) 的第二天凌晨 02:00。
+   - cron: "0 18 * * *"
+
+jobs:
+ close-issues:
+   runs-on: ubuntu-latest
+   permissions:
+     issues: write
+     pull-requests: write
+   steps:
+     - uses: actions/stale@v5
+       with:
+         # 标记 stale 标签时间
+         days-before-issue-stale: 30
+         # 关闭 issues 标签时间
+         days-before-issue-close: 14
+         # 自定义标签名
+         stale-issue-label: "stale"
+         stale-issue-message: "此问题已过时，因为它已打开 30 天且没有任何活动。"
+         close-issue-message: "此问题已关闭，因为它在标记为 stale 后，已处于无更新状态 14 天。"
+         # 忽略所有的 Pull Request，只处理 Issue
+         days-before-pr-stale: -1
+         days-before-pr-close: -1
+         # 排除带有RFC标签的issue
+         exempt-issue-labels: "RFC"
+         repo-token: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/pylint.yml

@@ -0,0 +1,91 @@
+name: Pylint Code Quality Check
+
+on:
+  # 允许手动触发
+  workflow_dispatch:
+
+jobs:
+  pylint:
+    runs-on: ubuntu-latest
+    name: Pylint Code Quality Check
+    
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.12'
+        cache: 'pip'
+        
+    - name: Cache pip dependencies
+      uses: actions/cache@v4
+      with:
+        path: ~/.cache/pip
+        key: ${{ runner.os }}-pip-${{ hashFiles('**/requirements.txt', '**/requirements.in') }}
+        restore-keys: |
+          ${{ runner.os }}-pip-
+          
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip setuptools wheel
+        pip install pylint
+        # 安装项目依赖
+        if [ -f requirements.txt ]; then
+          echo "📦 安装 requirements.txt 中的依赖..."
+          pip install -r requirements.txt
+        elif [ -f requirements.in ]; then
+          echo "📦 安装 requirements.in 中的依赖..."
+          pip install -r requirements.in
+        else
+          echo "⚠️ 未找到依赖文件，仅安装 pylint"
+        fi
+        
+    - name: Verify pylint config
+      run: |
+        # 检查项目中的pylint配置文件是否存在
+        if [ -f .pylintrc ]; then
+          echo "✅ 找到项目配置文件: .pylintrc"
+          echo "配置文件内容预览:"
+          head -10 .pylintrc
+        else
+          echo "❌ 未找到 .pylintrc 配置文件"
+          exit 1
+        fi
+    - name: Run pylint
+      run: |
+        # 运行pylint，检查主要的Python文件
+        echo "🚀 运行 Pylint 错误检查..."
+        
+        # 检查主要目录 - 只关注错误，如果有错误则退出
+        echo "📂 检查 app/ 目录..."
+        pylint app/ --output-format=colorized --reports=yes --score=yes
+        
+        # 检查根目录的Python文件
+        echo "📂 检查根目录 Python 文件..."
+        for file in $(find . -name "*.py" -not -path "./.*" -not -path "./.venv/*" -not -path "./build/*" -not -path "./dist/*" -not -path "./tests/*" -not -path "./docs/*" -not -path "./__pycache__/*" -maxdepth 1); do
+          echo "检查文件: $file"
+          pylint "$file" --output-format=colorized || exit 1
+        done
+        
+        # 生成详细报告
+        echo "📊 生成 Pylint 详细报告..."
+        pylint app/ --output-format=json > pylint-report.json || true
+        
+        # 显示评分（仅供参考）
+        echo "📈 Pylint 评分（仅供参考）:"
+        pylint app/ --score=yes --reports=no | tail -2 || true
+        
+    - name: Upload pylint report
+      uses: actions/upload-artifact@v4
+      if: always()
+      with:
+        name: pylint-report
+        path: pylint-report.json
+        
+    - name: Summary
+      run: |
+        echo "🎉 Pylint 检查完成！"
+        echo "✅ 没有发现语法错误或严重问题"
+        echo "📊 详细报告已保存为构建工件" 

.github/workflows/release.yml

@@ -1,36 +0,0 @@
-name: MoviePilot Release
-on:
-  workflow_dispatch:
-  push:
-    branches:
-      - main
-    paths:
-      - version.py
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    name: Build Docker Image
-    steps:
-      -
-        name: Checkout
-        uses: actions/checkout@v4
-
-      -
-        name: Release Version
-        id: release_version
-        run: |
-          app_version=$(cat version.py |sed -ne "s/APP_VERSION\s=\s'v\(.*\)'/\1/gp")
-          echo "app_version=$app_version" >> $GITHUB_ENV
-
-      -
-        name: Generate Release
-        uses: actions/create-release@latest
-        with:
-          tag_name: v${{ env.app_version }}
-          release_name: v${{ env.app_version }}
-          body: ${{ github.event.commits[0].message }}
-          draft: false
-          prerelease: false
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -1,8 +1,30 @@
 .idea/
 *.c
+*.so
+*.pyd
 build/
+cython_cache/
+dist/
+nginx/
 test.py
+safety_report.txt
 app/helper/sites.py
-config/user.db
+app/helper/*.so
+app/helper/*.pyd
+app/helper/*.bin
+app/plugins/**
+!app/plugins/__init__.py
+config/cookies/**
+config/user.db*
+config/sites/**
+config/logs/
+config/temp/
+config/cache/
 *.pyc
 *.log
+.vscode
+venv
+
+# Pylint
+pylint-report.json
+.pylint.d/

.pylintrc

@@ -0,0 +1,83 @@
+[MASTER]
+# 指定Python路径
+init-hook='import sys; sys.path.append(".")'
+
+# 忽略的文件和目录
+ignore=.git,__pycache__,.venv,build,dist,tests,docs
+
+# 并行作业数量
+jobs=0
+
+[MESSAGES CONTROL]
+# 只关注错误级别的问题，禁用警告、约定和重构建议
+# E = Error (错误) - 会导致构建失败
+# W = Warning (警告) - 仅显示，不会失败
+# R = Refactor (重构建议) - 仅显示，不会失败  
+# C = Convention (约定) - 仅显示，不会失败
+# I = Information (信息) - 仅显示，不会失败
+
+# 禁用大部分警告、约定和重构建议，只保留错误和重要警告
+disable=all
+enable=error,
+       syntax-error,
+       undefined-variable,
+       used-before-assignment,
+       unreachable,
+       return-outside-function,
+       yield-outside-function,
+       continue-in-finally,
+       nonlocal-without-binding,
+       undefined-loop-variable,
+       redefined-builtin,
+       not-callable,
+       assignment-from-no-return,
+       no-value-for-parameter,
+       too-many-function-args,
+       unexpected-keyword-arg,
+       redundant-keyword-arg,
+       import-error,
+       relative-beyond-top-level
+
+[REPORTS]
+# 设置报告格式
+output-format=colorized
+reports=yes
+score=yes
+
+[FORMAT]
+# 最大行长度
+max-line-length=120
+# 缩进大小
+indent-string='    '
+
+[DESIGN]
+# 最大参数数量
+max-args=10
+# 最大本地变量数量
+max-locals=20
+# 最大分支数量
+max-branches=15
+# 最大语句数量
+max-statements=50
+# 最大父类数量
+max-parents=7
+# 最大属性数量
+max-attributes=10
+# 最小公共方法数量
+min-public-methods=1
+# 最大公共方法数量
+max-public-methods=25
+
+[SIMILARITIES]
+# 最小相似行数
+min-similarity-lines=6
+# 忽略注释
+ignore-comments=yes
+# 忽略文档字符串
+ignore-docstrings=yes
+# 忽略导入
+ignore-imports=yes
+
+[TYPECHECK]
+# 生成缺失成员提示的类列表
+generated-members=requests.packages.urllib3 

README.md

@@ -1,281 +1,61 @@
 # MoviePilot
 
+![GitHub Repo stars](https://img.shields.io/github/stars/jxxghp/MoviePilot?style=for-the-badge)
+![GitHub forks](https://img.shields.io/github/forks/jxxghp/MoviePilot?style=for-the-badge)
+![GitHub contributors](https://img.shields.io/github/contributors/jxxghp/MoviePilot?style=for-the-badge)
+![GitHub repo size](https://img.shields.io/github/repo-size/jxxghp/MoviePilot?style=for-the-badge)
+![GitHub issues](https://img.shields.io/github/issues/jxxghp/MoviePilot?style=for-the-badge)
+![Docker Pulls](https://img.shields.io/docker/pulls/jxxghp/moviepilot?style=for-the-badge)
+![Docker Pulls V2](https://img.shields.io/docker/pulls/jxxghp/moviepilot-v2?style=for-the-badge)
+![Platform](https://img.shields.io/badge/platform-Windows%20%7C%20Linux%20%7C%20Synology-blue?style=for-the-badge)
+
+
 基于 [NAStool](https://github.com/NAStool/nas-tools) 部分代码重新设计，聚焦自动化核心需求，减少问题同时更易于扩展和维护。
 
 # 仅用于学习交流使用，请勿在任何国内平台宣传该项目！
 
-Docker：https://hub.docker.com/r/jxxghp/moviepilot
-
 发布频道：https://t.me/moviepilot_channel
 
 ## 主要特性
-- 前后端分离，基于FastApi + Vue3，前端项目地址：[MoviePilot-Frontend](https://github.com/jxxghp/MoviePilot-Frontend)
+
+- 前后端分离，基于FastApi + Vue3，前端项目地址：[MoviePilot-Frontend](https://github.com/jxxghp/MoviePilot-Frontend)，API：http://localhost:3001/docs
 - 聚焦核心需求，简化功能和设置，部分设置项可直接使用默认值。
 - 重新设计了用户界面，更加美观易用。
 
-## 安装
+## 安装使用
 
-1. **安装CookieCloud插件**
+访问官方Wiki：https://wiki.movie-pilot.org
 
-站点信息需要通过CookieCloud同步获取，因此需要安装CookieCloud插件，将浏览器中的站点Cookie数据同步到云端后再同步到MoviePilot使用。 插件下载地址请点击 [这里](https://github.com/easychen/CookieCloud/releases)。
+## 参与开发
 
-2. **安装CookieCloud服务端（可选）**
-
-MoviePilot内置了公共CookieCloud服务器，如果需要自建服务，可参考 [CookieCloud](https://github.com/easychen/CookieCloud) 项目进行搭建，docker镜像请点击 [这里](https://hub.docker.com/r/easychen/cookiecloud)。
-
-**声明：** 本项目不会收集用户敏感数据，Cookie同步也是基于CookieCloud项目实现，非本项目提供的能力。技术角度上CookieCloud采用端到端加密，在个人不泄露`用户KEY`和`端对端加密密码`的情况下第三方无法窃取任何用户信息（包括服务器持有者）。如果你不放心，可以不使用公共服务或者不使用本项目，但如果使用后发生了任何信息泄露与本项目无关！
-
-3. **安装配套管理软件**
-
-MoviePilot需要配套下载器和媒体服务器配合使用。
-- 下载器支持：qBittorrent、Transmission，QB版本号要求>= 4.3.9，TR版本号要求>= 3.0，推荐使用QB。
-- 媒体服务器支持：Jellyfin、Emby、Plex，推荐使用Emby。
-
-4. **安装MoviePilot**
-
-目前仅提供docker镜像，点击 [这里](https://hub.docker.com/r/jxxghp/moviepilot) 或执行命令：
+需要 `Python 3.12`、`Node JS v20.12.1`
 
+- 克隆主项目 [MoviePilot](https://github.com/jxxghp/MoviePilot) 
 ```shell
-docker pull jxxghp/moviepilot:latest
+git clone https://github.com/jxxghp/MoviePilot
 ```
-
-## 配置
-
-项目的所有配置均通过环境变量进行设置，支持两种配置方式：
-1. 在docker环境变量部分进行参数配置，部分环境建立容器后会自动显示待配置项，如未自动显示配置项则需要手动增加对应环境变量。
-2. 下载 [app.env](https://github.com/jxxghp/MoviePilot/raw/main/config/app.env) 文件，修改好配置后放置到配置文件映射路径根目录，配置项可根据说明自主增减。
-
-配置文件映射路径：`/config`，配置项生效优先级：环境变量 > env文件 > 默认值，部分参数如路径映射、站点认证等必须通过环境变量进行配置。
-
-### 1. **基础设置**
-
-- **PUID**：运行程序用户的`uid`，默认`0`
-- **PGID**：运行程序用户的`gid`，默认`0`
-- **UMASK**：掩码权限，默认`000`，可以考虑设置为`022`
-- **MOVIEPILOT_AUTO_UPDATE**：重启更新，`true`/`false`，默认`true` **注意：如果出现网络问题可以配置`PROXY_HOST`，具体看下方`PROXY_HOST`解释**
-- **MOVIEPILOT_AUTO_UPDATE_DEV**：重启时更新到未发布的开发版本代码，`true`/`false`，默认`false`
-- **NGINX_PORT：** WEB服务端口，默认`3000`，可自行修改，不能与API服务端口冲突
-- **PORT：** API服务端口，默认`3001`，可自行修改，不能与WEB服务端口冲突
-- **SUPERUSER：** 超级管理员用户名，默认`admin`，安装后使用该用户登录后台管理界面
-- **SUPERUSER_PASSWORD：** 超级管理员初始密码，默认`password`，建议修改为复杂密码
-- **API_TOKEN：** API密钥，默认`moviepilot`，在媒体服务器Webhook、微信回调等地址配置中需要加上`?token=`该值，建议修改为复杂字符串
-- **PROXY_HOST：** 网络代理（可选），访问themoviedb或者重启更新需要使用代理访问，格式为`http(s)://ip:port`
-- **TMDB_API_DOMAIN：** TMDB API地址，默认`api.themoviedb.org`，也可配置为`api.tmdb.org`或其它中转代理服务地址，能连通即可
-- **DOWNLOAD_PATH：** 下载保存目录，**注意：需要将`moviepilot`及`下载器`的映射路径保持一致**，否则会导致下载文件无法转移
-- **DOWNLOAD_MOVIE_PATH：** 电影下载保存目录，不设置则下载到`DOWNLOAD_PATH`
-- **DOWNLOAD_TV_PATH：** 电视剧下载保存目录，不设置则下载到`DOWNLOAD_PATH`
-- **DOWNLOAD_ANIME_PATH：** 动漫下载保存目录，不设置则下载到`DOWNLOAD_PATH`
-- **DOWNLOAD_CATEGORY：** 下载二级分类开关，`true`/`false`，默认`false`，开启后会根据配置 [category.yaml](https://github.com/jxxghp/MoviePilot/raw/main/config/category.yaml) 自动在下载目录下建立二级目录分类
-- **DOWNLOAD_SUBTITLE：** 下载站点字幕，`true`/`false`，默认`true`
-- **REFRESH_MEDIASERVER：** 入库刷新媒体库，`true`/`false`，默认`true`
-- **SCRAP_METADATA：** 刮削入库的媒体文件，`true`/`false`，默认`true`
-- **SCRAP_FOLLOW_TMDB：** 新增已入库媒体是否跟随TMDB信息变化，`true`/`false`，默认`true`
-- **TORRENT_TAG：** 种子标签，默认为`MOVIEPILOT`，设置后只有MoviePilot添加的下载才会处理，留空所有下载器中的任务均会处理
-- **LIBRARY_PATH：** 媒体库目录，多个目录使用`,`分隔
-- **LIBRARY_MOVIE_NAME：** 电影媒体库目录名，默认`电影`
-- **LIBRARY_TV_NAME：** 电视剧媒体库目录名，默认`电视剧`
-- **LIBRARY_ANIME_NAME：** 动漫媒体库目录名，默认`电视剧/动漫`
-- **LIBRARY_CATEGORY：** 媒体库二级分类开关，`true`/`false`，默认`false`，开启后会根据配置 [category.yaml](https://github.com/jxxghp/MoviePilot/raw/main/config/category.yaml) 自动在媒体库目录下建立二级目录分类
-- **TRANSFER_TYPE：** 转移方式，支持`link`/`copy`/`move`/`softlink`  **注意：在`link`和`softlink`转移方式下，转移后的文件会继承源文件的权限掩码，不受`UMASK`影响**
-- **COOKIECLOUD_HOST：** CookieCloud服务器地址，格式：`http(s)://ip:port`，不配置默认使用内建服务器`https://movie-pilot.org/cookiecloud`
-- **COOKIECLOUD_KEY：** CookieCloud用户KEY
-- **COOKIECLOUD_PASSWORD：** CookieCloud端对端加密密码
-- **COOKIECLOUD_INTERVAL：** CookieCloud同步间隔（分钟）
-- **OCR_HOST：** OCR识别服务器地址，格式：`http(s)://ip:port`，用于识别站点二维码实现自动登录获取Cookie等，不配置默认使用内建服务器`https://movie-pilot.org`，可使用 [这个镜像](https://hub.docker.com/r/jxxghp/moviepilot-ocr) 自行搭建。
-- **USER_AGENT：** CookieCloud对应的浏览器UA，可选，设置后可增加连接站点的成功率，同步站点后可以在管理界面中修改
-- **AUTO_DOWNLOAD_USER：** 交互搜索自动下载用户ID，使用,分割
-- **SUBSCRIBE_MODE：** 订阅模式，`rss`/`spider`，默认`spider`，`rss`模式通过定时刷新RSS来匹配订阅（RSS地址会自动获取，也可手动维护），对站点压力小，同时可设置订阅刷新周期，24小时运行，但订阅和下载通知不能过滤和显示免费，推荐使用rss模式。
-- **SUBSCRIBE_RSS_INTERVAL：** RSS订阅模式刷新时间间隔（分钟），默认`30`分钟，不能小于5分钟。
-- **SUBSCRIBE_SEARCH：** 订阅搜索，`true`/`false`，默认`false`，开启后会每隔24小时对所有订阅进行全量搜索，以补齐缺失剧集（一般情况下正常订阅即可，订阅搜索只做为兜底，会增加站点压力，不建议开启）。
-- **MESSAGER：** 消息通知渠道，支持 `telegram`/`wechat`/`slack`/`synologychat`，开启多个渠道时使用`,`分隔。同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`telegram`
-
-  - `wechat`设置项：
-
-    - **WECHAT_CORPID：** WeChat企业ID
-    - **WECHAT_APP_SECRET：** WeChat应用Secret
-    - **WECHAT_APP_ID：** WeChat应用ID
-    - **WECHAT_TOKEN：** WeChat消息回调的Token
-    - **WECHAT_ENCODING_AESKEY：** WeChat消息回调的EncodingAESKey
-    - **WECHAT_ADMINS：** WeChat管理员列表，多个管理员用英文逗号分隔（可选）
-    - **WECHAT_PROXY：** WeChat代理服务器（后面不要加/）
-
-  - `telegram`设置项：
-
-    - **TELEGRAM_TOKEN：** Telegram Bot Token
-    - **TELEGRAM_CHAT_ID：** Telegram Chat ID
-    - **TELEGRAM_USERS：** Telegram 用户ID，多个使用,分隔，只有用户ID在列表中才可以使用Bot，如未设置则均可以使用Bot
-    - **TELEGRAM_ADMINS：** Telegram 管理员ID，多个使用,分隔，只有管理员才可以操作Bot菜单，如未设置则均可以操作菜单
-
-  - `slack`设置项：
-
-    - **SLACK_OAUTH_TOKEN：** Slack Bot User OAuth Token
-    - **SLACK_APP_TOKEN：** Slack App-Level Token
-    - **SLACK_CHANNEL：** Slack 频道名称，默认`全体`
-  
-  - `synologychat`设置项：
-
-    - **SYNOLOGYCHAT_WEBHOOK：** 在Synology Chat中创建机器人，获取机器人`传入URL`
-    - **SYNOLOGYCHAT_TOKEN：** SynologyChat机器人`令牌`
-
-
-- **DOWNLOADER：** 下载器，支持`qbittorrent`/`transmission`，QB版本号要求>= 4.3.9，TR版本号要求>= 3.0，同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`qbittorrent`
-
-  - `qbittorrent`设置项：
-
-    - **QB_HOST：** qbittorrent地址，格式：`ip:port`，https需要添加`https://`前缀
-    - **QB_USER：** qbittorrent用户名
-    - **QB_PASSWORD：** qbittorrent密码
-    - **QB_CATEGORY：** qbittorrent分类自动管理，`true`/`false`，默认`false`，开启后会将下载二级分类传递到下载器，由下载器管理下载目录，需要同步开启`DOWNLOAD_CATEGORY`
-
-  - `transmission`设置项：
-
-    - **TR_HOST：** transmission地址，格式：`ip:port`，https需要添加`https://`前缀
-    - **TR_USER：** transmission用户名
-    - **TR_PASSWORD：** transmission密码
-
-- **DOWNLOADER_MONITOR：** 下载器监控，`true`/`false`，默认为`true`，开启后下载完成时才会自动整理入库
-
-- **MEDIASERVER：** 媒体服务器，支持`emby`/`jellyfin`/`plex`，同时开启多个使用`,`分隔。还需要配置对应媒体服务器的环境变量，非对应媒体服务器的变量可删除，推荐使用`emby`
-
-  - `emby`设置项：
-
-    - **EMBY_HOST：** Emby服务器地址，格式：`ip:port`，https需要添加`https://`前缀
-    - **EMBY_API_KEY：** Emby Api Key，在`设置->高级->API密钥`处生成
-
-  - `jellyfin`设置项：
-
-    - **JELLYFIN_HOST：** Jellyfin服务器地址，格式：`ip:port`，https需要添加`https://`前缀
-    - **JELLYFIN_API_KEY：** Jellyfin Api Key，在`设置->高级->API密钥`处生成
-
-  - `plex`设置项：
-
-    - **PLEX_HOST：** Plex服务器地址，格式：`ip:port`，https需要添加`https://`前缀
-    - **PLEX_TOKEN：** Plex网页Url中的`X-Plex-Token`，通过浏览器F12->网络从请求URL中获取
-
-- **MEDIASERVER_SYNC_INTERVAL:** 媒体服务器同步间隔（小时），默认`6`，留空则不同步
-- **MEDIASERVER_SYNC_BLACKLIST:** 媒体服务器同步黑名单，多个媒体库名称使用,分割
-
-
-### 2. **用户认证**
-
-`MoviePilot`需要认证后才能使用，配置`AUTH_SITE`后，需要根据下表配置对应站点的认证参数（**仅能通过docker环境变量配置**）
-
-- **AUTH_SITE：** 认证站点，支持`iyuu`/`hhclub`/`audiences`/`hddolby`/`zmpt`/`freefarm`/`hdfans`/`wintersakura`/`leaves`/`1ptba`/`icc2022`/`ptlsp`/`xingtan`
-
-|      站点      |                          参数                           |
-|:------------:|:-----------------------------------------------------:|
-|     iyuu     |                 `IYUU_SIGN`：IYUU登录令牌                  |
-|    hhclub    |     `HHCLUB_USERNAME`：用户名<br/>`HHCLUB_PASSKEY`：密钥     |
-|  audiences   |    `AUDIENCES_UID`：用户ID<br/>`AUDIENCES_PASSKEY`：密钥    |
-|   hddolby    |      `HDDOLBY_ID`：用户ID<br/>`HDDOLBY_PASSKEY`：密钥       |
-|     zmpt     |         `ZMPT_UID`：用户ID<br/>`ZMPT_PASSKEY`：密钥         |
-|   freefarm   |     `FREEFARM_UID`：用户ID<br/>`FREEFARM_PASSKEY`：密钥     |
-|    hdfans    |       `HDFANS_UID`：用户ID<br/>`HDFANS_PASSKEY`：密钥       |
-| wintersakura | `WINTERSAKURA_UID`：用户ID<br/>`WINTERSAKURA_PASSKEY`：密钥 |
-|    leaves    |       `LEAVES_UID`：用户ID<br/>`LEAVES_PASSKEY`：密钥       |
-|    1ptba     |        `1PTBA_UID`：用户ID<br/>`1PTBA_PASSKEY`：密钥        |
-|   icc2022    |      `ICC2022_UID`：用户ID<br/>`ICC2022_PASSKEY`：密钥      |
-|    ptlsp     |        `PTLSP_UID`：用户ID<br/>`PTLSP_PASSKEY`：密钥        |
-|   xingtan    |      `XINGTAN_UID`：用户ID<br/>`XINGTAN_PASSKEY`：密钥      |
-
-
-### 2. **进阶配置**
-
-- **BIG_MEMORY_MODE：** 大内存模式，默认为`false`，开启后会占用更多的内存，但响应速度会更快
-
-- **MOVIE_RENAME_FORMAT：** 电影重命名格式
-
-`MOVIE_RENAME_FORMAT`支持的配置项：
-
-> `title`： 标题  
-> `original_name`： 原文件名  
-> `original_title`： 原语种标题  
-> `name`： 识别名称  
-> `year`： 年份  
-> `resourceType`：资源类型  
-> `effect`：特效  
-> `edition`： 版本（资源类型+特效）  
-> `videoFormat`： 分辨率  
-> `releaseGroup`： 制作组/字幕组  
-> `videoCodec`： 视频编码  
-> `audioCodec`： 音频编码  
-> `tmdbid`： TMDBID  
-> `imdbid`： IMDBID  
-> `part`：段/节  
-> `fileExt`：文件扩展名
-
-`MOVIE_RENAME_FORMAT`默认配置格式：
-
+- 克隆资源项目 [MoviePilot-Resources](https://github.com/jxxghp/MoviePilot-Resources) ，将 `resources` 目录下对应平台及版本的库 `.so`/`.pyd`/`.bin` 文件复制到 `app/helper` 目录
+```shell
+git clone https://github.com/jxxghp/MoviePilot-Resources
 ```
-{{title}}{% if year %} ({{year}}){% endif %}/{{title}}{% if year %} ({{year}}){% endif %}{% if part %}-{{part}}{% endif %}{% if videoFormat %} - {{videoFormat}}{% endif %}{{fileExt}}
+- 安装后端依赖，设置`app`为源代码根目录，运行 `main.py` 启动后端服务，默认监听端口：`3001`，API文档地址：`http://localhost:3001/docs`
+```shell
+pip install -r requirements.txt
+python3 main.py
 ```
-
-- **TV_RENAME_FORMAT：** 电视剧重命名格式
-
-`TV_RENAME_FORMAT`额外支持的配置项：
-
-> `season`： 季号  
-> `episode`： 集号  
-> `season_episode`： 季集 SxxExx  
-> `episode_title`： 集标题
-
-`TV_RENAME_FORMAT`默认配置格式：
-
+- 克隆前端项目 [MoviePilot-Frontend](https://github.com/jxxghp/MoviePilot-Frontend)
+```shell
+git clone https://github.com/jxxghp/MoviePilot-Frontend
 ```
-{{title}}{% if year %} ({{year}}){% endif %}/Season {{season}}/{{title}} - {{season_episode}}{% if part %}-{{part}}{% endif %}{% if episode %} - 第 {{episode}} 集{% endif %}{{fileExt}}
+- 安装前端依赖，运行前端项目，访问：`http://localhost:5173`
+```shell
+yarn
+yarn dev
 ```
+- 参考 [插件开发指引](https://wiki.movie-pilot.org/zh/plugindev) 在 `app/plugins` 目录下开发插件代码
 
+## 贡献者
 
-### 3. **过滤规则**
-
-在`设定`-`规则`中设定，规则说明：
-
-- 仅支持使用内置规则进行排列组合，内置规则有：`蓝光原盘`、`4K`、`1080P`、`中文字幕`、`特效字幕`、`H265`、`H264`、`杜比`、`HDR`、`REMUX`、`WEB-DL`、`免费`、`国语配音` 等
-- 符合任一层级规则的资源将被标识选中，匹配成功的层级做为该资源的优先级，排越前面优先级超高
-- 不符合过滤规则所有层级规则的资源将不会被选中
-
-
-## 使用
-
-- 通过CookieCloud同步快速同步站点，不需要使用的站点可在WEB管理界面中禁用，无法同步的站点可手动新增。
-- 通过WEB进行管理，将WEB添加到手机桌面获得类App使用效果，管理界面端口：`3000`，后台API端口：`3001`。
-- 通过下载器监控或使用目录监控插件实现自动整理入库刮削（二选一）。
-- 通过微信/Telegram/Slack/SynologyChat远程管理，其中微信/Telegram将会自动添加操作菜单（微信菜单条数有限制，部分菜单不显示）；微信需要在官方页面设置回调地址，SynologyChat需要设置机器人传入地址，地址相对路径为：`/api/v1/message/`。
-- 设置媒体服务器Webhook，通过MoviePilot发送播放通知等。Webhook回调相对路径为`/api/v1/webhook?token=moviepilot`（`3001`端口），其中`moviepilot`为设置的`API_TOKEN`。
-- 将MoviePilot做为Radarr或Sonarr服务器添加到Overseerr或Jellyseerr（`API服务端口`），可使用Overseerr/Jellyseerr浏览订阅。
-- 映射宿主机docker.sock文件到容器`/var/run/docker.sock`，以支持内建重启操作。实例：`-v /var/run/docker.sock:/var/run/docker.sock:ro`
-
-**注意**
-
-1) 容器首次启动需要下载浏览器内核，根据网络情况可能需要较长时间，此时无法登录。可映射`/moviepilot`目录避免容器重置后重新触发浏览器内核下载。
-2) 使用反向代理时，需要添加以下配置，否则可能会导致部分功能无法访问（`ip:port`修改为实际值）：
-```nginx configuration
-location / {
-    proxy_pass http://ip:port;
-    proxy_set_header Host $http_host;
-    proxy_set_header X-Real-IP $remote_addr;
-    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
-    proxy_set_header X-Forwarded-Proto $scheme;
-}
-```
-3) 新建的企业微信应用需要固定公网IP的代理才能收到消息，代理添加以下代码：
-```nginx configuration
-location /cgi-bin/gettoken {
-    proxy_pass https://qyapi.weixin.qq.com;
-}
-location /cgi-bin/message/send {
-    proxy_pass https://qyapi.weixin.qq.com;
-}
-location  /cgi-bin/menu/create {
-    proxy_pass https://qyapi.weixin.qq.com;
-}
-```
-
-![image](https://github.com/jxxghp/MoviePilot/assets/51039935/f2654b09-26f3-464f-a0af-1de3f97832ee)
-
-![image](https://github.com/jxxghp/MoviePilot/assets/51039935/fcb87529-56dd-43df-8337-6e34b8582819)
-
-![image](https://github.com/jxxghp/MoviePilot/assets/51039935/bfa77c71-510a-46a6-9c1e-cf98cb101e3a)
-
-![image](https://github.com/jxxghp/MoviePilot/assets/51039935/51cafd09-e38c-47f9-ae62-1e83ab8bf89b)
-
+<a href="https://github.com/jxxghp/MoviePilot/graphs/contributors">
+  <img src="https://contrib.rocks/image?repo=jxxghp/MoviePilot" />
+</a>

alembic/versions/14f1813ae8e3_1_0_1.py

@@ -1,31 +0,0 @@
-"""1.0.1
-
-Revision ID: 14f1813ae8e3
-Revises: 9f4edd55c2d4
-Create Date: 2023-07-27 12:34:57.839443
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = '14f1813ae8e3'
-down_revision = '9f4edd55c2d4'
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    try:
-        with op.batch_alter_table("subscribe") as batch_op:
-            batch_op.add_column(sa.Column('best_version', sa.Integer, nullable=True))
-            batch_op.add_column(sa.Column('current_priority', sa.Integer, nullable=True))
-    except Exception as e:
-        pass
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    pass

alembic/versions/1e169250e949_1_0_4.py

@@ -1,30 +0,0 @@
-"""1.0.4
-
-Revision ID: 1e169250e949
-Revises: 52ab4930be04
-Create Date: 2023-09-01 09:56:33.907661
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = '1e169250e949'
-down_revision = '52ab4930be04'
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    try:
-        with op.batch_alter_table("subscribe") as batch_op:
-            batch_op.add_column(sa.Column('date', sa.String, nullable=True))
-    except Exception as e:
-        pass
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    pass

alembic/versions/232dfa044617_1_0_6.py

@@ -1,40 +0,0 @@
-"""1.0.6
-
-Revision ID: 232dfa044617
-Revises: e734c7fe6056
-Create Date: 2023-09-19 21:34:41.994617
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = '232dfa044617'
-down_revision = 'e734c7fe6056'
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    # 搜索优先级
-    op.execute("delete from systemconfig where key = 'SearchFilterRules';")
-    op.execute(
-        "insert into systemconfig(key, value) VALUES('SearchFilterRules', (select value from systemconfig where key= 'FilterRules'));")
-    # 订阅优先级
-    op.execute("delete from systemconfig where key = 'SubscribeFilterRules';")
-    op.execute(
-        "insert into systemconfig(key, value) VALUES('SubscribeFilterRules', (select value from systemconfig where key= 'FilterRules'));")
-    # 洗版优先级
-    op.execute("delete from systemconfig where key = 'BestVersionFilterRules';")
-    op.execute(
-        "insert into systemconfig(key, value) VALUES('BestVersionFilterRules', (select value from systemconfig where key= 'FilterRules2'));")
-    # 删除旧的优先级规则
-    op.execute("delete from systemconfig where key = 'FilterRules';")
-    op.execute("delete from systemconfig where key = 'FilterRules2';")
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    pass

alembic/versions/30329639c12b_1_0_7.py

@@ -1,29 +0,0 @@
-"""1.0.7
-
-Revision ID: 30329639c12b
-Revises: 232dfa044617
-Create Date: 2023-09-23 08:25:59.776488
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = '30329639c12b'
-down_revision = '232dfa044617'
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.execute("delete from systemconfig where key = 'DefaultFilterRules';")
-    op.execute(
-        "insert into systemconfig(key, value) VALUES('DefaultFilterRules', (select value from systemconfig where key= 'DefaultIncludeExcludeFilter'));")
-    op.execute("delete from systemconfig where key = 'DefaultIncludeExcludeFilter';")
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    pass

alembic/versions/52ab4930be04_1_0_3.py

@@ -1,28 +0,0 @@
-"""1_0_3
-
-Revision ID: 52ab4930be04
-Revises: ec5fb51fc300
-Create Date: 2023-08-28 13:21:45.152012
-
-"""
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision = '52ab4930be04'
-down_revision = 'ec5fb51fc300'
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    op.execute("delete from systemconfig where key = 'RssSites';")
-    op.execute("insert into systemconfig(key, value) VALUES('RssSites', (select value from systemconfig where key= 'IndexerSites'));")
-    op.execute("delete from systemconfig where key = 'SearchResults';")
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    pass
-    # ### end Alembic commands ###

alembic/versions/9f4edd55c2d4_1_0_0.py

@@ -1,32 +0,0 @@
-"""1.0.0
-
-Revision ID: 9f4edd55c2d4
-Revises: 
-Create Date: 2023-07-13 12:27:26.402317
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = '9f4edd55c2d4'
-down_revision = None
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    try:
-        with op.batch_alter_table("subscribe") as batch_op:
-            batch_op.add_column(sa.Column('sites', sa.Text, nullable=True))
-    except Exception as e:
-        pass
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    pass
-    # ### end Alembic commands ###

alembic/versions/a521fbc28b18_1_0_9.py

@@ -1,30 +0,0 @@
-"""1_0_9
-
-Revision ID: a521fbc28b18
-Revises: b2f011d3a8b7
-Create Date: 2023-09-28 13:37:16.479360
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = 'a521fbc28b18'
-down_revision = 'b2f011d3a8b7'
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    try:
-        with op.batch_alter_table("downloadhistory") as batch_op:
-            batch_op.add_column(sa.Column('date', sa.String, nullable=True))
-            batch_op.add_column(sa.Column('channel', sa.String, nullable=True))
-    except Exception as e:
-        pass
-    # ### end Alembic commands ###
-
-def downgrade() -> None:
-    pass

alembic/versions/b2f011d3a8b7_1_0_8.py

@@ -1,29 +0,0 @@
-"""1_0_8
-
-Revision ID: b2f011d3a8b7
-Revises: 30329639c12b
-Create Date: 2023-09-28 10:15:58.410003
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = 'b2f011d3a8b7'
-down_revision = '30329639c12b'
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    try:
-        with op.batch_alter_table("downloadhistory") as batch_op:
-            batch_op.add_column(sa.Column('userid', sa.String, nullable=True))
-    except Exception as e:
-        pass
-    # ### end Alembic commands ###
-
-def downgrade() -> None:
-    pass

alembic/versions/e734c7fe6056_1_0_5.py

@@ -1,27 +0,0 @@
-"""1.0.5
-
-Revision ID: e734c7fe6056
-Revises: 1e169250e949
-Create Date: 2023-09-07 18:19:41.250957
-
-"""
-from alembic import op
-
-# revision identifiers, used by Alembic.
-revision = 'e734c7fe6056'
-down_revision = '1e169250e949'
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    try:
-        op.create_index('ix_transferhistory_tmdbid', 'transferhistory', ['tmdbid'], unique=False)
-    except Exception as err:
-        pass
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    pass

alembic/versions/ec5fb51fc300_1_0_2.py

@@ -1,32 +0,0 @@
-"""1.0.2
-
-Revision ID: ec5fb51fc300
-Revises: 14f1813ae8e3
-Create Date: 2023-08-12 17:55:06.509548
-
-"""
-from alembic import op
-import sqlalchemy as sa
-
-
-# revision identifiers, used by Alembic.
-revision = 'ec5fb51fc300'
-down_revision = '14f1813ae8e3'
-branch_labels = None
-depends_on = None
-
-
-def upgrade() -> None:
-    # ### commands auto generated by Alembic - please adjust! ###
-    try:
-        with op.batch_alter_table("transferhistory") as batch_op:
-            batch_op.add_column(sa.Column('files', sa.String, nullable=True))
-        with op.batch_alter_table("rss") as batch_op:
-            batch_op.add_column(sa.Column('filter', sa.Integer, nullable=True))
-    except Exception as e:
-        pass
-    # ### end Alembic commands ###
-
-
-def downgrade() -> None:
-    pass

app/actions/__init__.py

@@ -0,0 +1,106 @@
+from abc import ABC, abstractmethod
+from typing import Union
+
+from app.chain import ChainBase
+from app.db.systemconfig_oper import SystemConfigOper
+from app.schemas import ActionContext, ActionParams
+
+
+class ActionChain(ChainBase):
+    pass
+
+
+class BaseAction(ABC):
+    """
+    工作流动作基类
+    """
+
+    # 动作ID
+    _action_id = None
+    # 完成标志
+    _done_flag = False
+    # 执行信息
+    _message = ""
+    # 缓存键值
+    _cache_key = "WorkflowCache-%s"
+
+    def __init__(self, action_id: str):
+        self._action_id = action_id
+        self.systemconfigoper = SystemConfigOper()
+
+    @classmethod
+    @property
+    @abstractmethod
+    def name(cls) -> str:  # noqa
+        pass
+
+    @classmethod
+    @property
+    @abstractmethod
+    def description(cls) -> str:  # noqa
+        pass
+
+    @classmethod
+    @property
+    @abstractmethod
+    def data(cls) -> dict:  # noqa
+        pass
+
+    @property
+    def done(self) -> bool:
+        """
+        判断动作是否完成
+        """
+        return self._done_flag
+
+    @property
+    @abstractmethod
+    def success(self) -> bool:
+        """
+        判断动作是否成功
+        """
+        pass
+
+    @property
+    def message(self) -> str:
+        """
+        执行信息
+        """
+        return self._message
+
+    def job_done(self, message: str = None):
+        """
+        标记动作完成
+        """
+        self._message = message
+        self._done_flag = True
+
+    def check_cache(self, workflow_id: int, key: str) -> bool:
+        """
+        检查是否处理过
+        """
+        workflow_key = self._cache_key % workflow_id
+        workflow_cache = self.systemconfigoper.get(workflow_key) or {}
+        action_cache = workflow_cache.get(self._action_id) or []
+        return key in action_cache
+
+    def save_cache(self, workflow_id: int, data: Union[list, str]):
+        """
+        保存缓存
+        """
+        workflow_key = self._cache_key % workflow_id
+        workflow_cache = self.systemconfigoper.get(workflow_key) or {}
+        action_cache = workflow_cache.get(self._action_id) or []
+        if isinstance(data, list):
+            action_cache.extend(data)
+        else:
+            action_cache.append(data)
+        workflow_cache[self._action_id] = action_cache
+        self.systemconfigoper.set(workflow_key, workflow_cache)
+
+    @abstractmethod
+    def execute(self, workflow_id: int, params: ActionParams, context: ActionContext) -> ActionContext:
+        """
+        执行动作
+        """
+        raise NotImplementedError

app/actions/add_download.py

@@ -0,0 +1,116 @@
+from typing import Optional
+
+from pydantic import Field
+
+from app.actions import BaseAction
+from app.chain.download import DownloadChain
+from app.chain.media import MediaChain
+from app.core.config import global_vars
+from app.core.metainfo import MetaInfo
+from app.log import logger
+from app.schemas import ActionParams, ActionContext, DownloadTask, MediaType
+
+
+class AddDownloadParams(ActionParams):
+    """
+    添加下载资源参数
+    """
+    downloader: Optional[str] = Field(default=None, description="下载器")
+    save_path: Optional[str] = Field(default=None, description="保存路径")
+    labels: Optional[str] = Field(default=None, description="标签（,分隔）")
+    only_lack: Optional[bool] = Field(default=False, description="仅下载缺失的资源")
+
+
+class AddDownloadAction(BaseAction):
+    """
+    添加下载资源
+    """
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self._added_downloads = []
+        self._has_error = False
+
+    @classmethod
+    @property
+    def name(cls) -> str:  # noqa
+        return "添加下载"
+
+    @classmethod
+    @property
+    def description(cls) -> str:  # noqa
+        return "根据资源列表添加下载任务"
+
+    @classmethod
+    @property
+    def data(cls) -> dict:  # noqa
+        return AddDownloadParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return not self._has_error
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        将上下文中的torrents添加到下载任务中
+        """
+        params = AddDownloadParams(**params)
+        _started = False
+        for t in context.torrents:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            # 检查缓存
+            cache_key = f"{t.torrent_info.site}-{t.torrent_info.title}"
+            if self.check_cache(workflow_id, cache_key):
+                logger.info(f"{t.torrent_info.title} 已添加过下载，跳过")
+                continue
+            if not t.meta_info:
+                t.meta_info = MetaInfo(title=t.torrent_info.title, subtitle=t.torrent_info.description)
+            if not t.media_info:
+                t.media_info = MediaChain().recognize_media(meta=t.meta_info)
+            if not t.media_info:
+                self._has_error = True
+                logger.warning(f"{t.torrent_info.title} 未识别到媒体信息，无法下载")
+                continue
+            if params.only_lack:
+                exists_info = DownloadChain().media_exists(t.media_info)
+                if exists_info:
+                    if t.media_info.type == MediaType.MOVIE:
+                        # 电影
+                        logger.warning(f"{t.torrent_info.title} 媒体库中已存在，跳过")
+                        continue
+                    else:
+                        # 电视剧
+                        exists_seasons = exists_info.seasons or {}
+                        if len(t.meta_info.season_list) > 1:
+                            # 多季不下载
+                            logger.warning(f"{t.meta_info.title} 有多季，跳过")
+                            continue
+                        else:
+                            exists_episodes = exists_seasons.get(t.meta_info.begin_season)
+                            if exists_episodes:
+                                if set(t.meta_info.episode_list).issubset(exists_episodes):
+                                    logger.warning(
+                                        f"{t.meta_info.title} 第 {t.meta_info.begin_season} 季第 {t.meta_info.episode_list} 集已存在，跳过")
+                                    continue
+
+            _started = True
+            did = DownloadChain().download_single(context=t,
+                                                  downloader=params.downloader,
+                                                  save_path=params.save_path,
+                                                  label=params.labels)
+            if did:
+                self._added_downloads.append(did)
+                # 保存缓存
+                self.save_cache(workflow_id, cache_key)
+
+        if self._added_downloads:
+            logger.info(f"已添加 {len(self._added_downloads)} 个下载任务")
+            context.downloads.extend(
+                [DownloadTask(download_id=did, downloader=params.downloader) for did in self._added_downloads]
+            )
+        elif _started:
+            self._has_error = True
+
+        self.job_done(f"已添加 {len(self._added_downloads)} 个下载任务")
+        return context

app/actions/add_subscribe.py

@@ -0,0 +1,88 @@
+from app.actions import BaseAction
+from app.chain.subscribe import SubscribeChain
+from app.core.config import settings, global_vars
+from app.core.context import MediaInfo
+from app.db.subscribe_oper import SubscribeOper
+from app.log import logger
+from app.schemas import ActionParams, ActionContext
+
+
+class AddSubscribeParams(ActionParams):
+    """
+    添加订阅参数
+    """
+    pass
+
+
+class AddSubscribeAction(BaseAction):
+    """
+    添加订阅
+    """
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self._added_subscribes = []
+        self._has_error = False
+
+    @classmethod
+    @property
+    def name(cls) -> str:  # noqa
+        return "添加订阅"
+
+    @classmethod
+    @property
+    def description(cls) -> str:  # noqa
+        return "根据媒体列表添加订阅"
+
+    @classmethod
+    @property
+    def data(cls) -> dict:  # noqa
+        return AddSubscribeParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return not self._has_error
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        将medias中的信息添加订阅，如果订阅不存在的话
+        """
+        _started = False
+        for media in context.medias:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            # 检查缓存
+            cache_key = f"{media.type}-{media.title}-{media.year}-{media.season}"
+            if self.check_cache(workflow_id, cache_key):
+                logger.info(f"{media.title} {media.year} 已添加过订阅，跳过")
+                continue
+            mediainfo = MediaInfo()
+            mediainfo.from_dict(media.dict())
+            subscribechain = SubscribeChain()
+            if subscribechain.exists(mediainfo):
+                logger.info(f"{media.title} 已存在订阅")
+                continue
+            # 添加订阅
+            _started = True
+            sid, message = subscribechain.add(mtype=mediainfo.type,
+                                              title=mediainfo.title,
+                                              year=mediainfo.year,
+                                              tmdbid=mediainfo.tmdb_id,
+                                              season=mediainfo.season,
+                                              doubanid=mediainfo.douban_id,
+                                              bangumiid=mediainfo.bangumi_id,
+                                              username=settings.SUPERUSER)
+            if sid:
+                self._added_subscribes.append(sid)
+                # 保存缓存
+                self.save_cache(workflow_id, cache_key)
+
+        if self._added_subscribes:
+            logger.info(f"已添加 {len(self._added_subscribes)} 个订阅")
+            for sid in self._added_subscribes:
+                context.subscribes.append(SubscribeOper().get(sid))
+        elif _started:
+            self._has_error = True
+
+        self.job_done(f"已添加 {len(self._added_subscribes)} 个订阅")
+        return context

app/actions/fetch_downloads.py

@@ -0,0 +1,65 @@
+from app.actions import BaseAction, ActionChain
+from app.core.config import global_vars
+from app.schemas import ActionParams, ActionContext
+from app.log import logger
+
+
+class FetchDownloadsParams(ActionParams):
+    """
+    获取下载任务参数
+    """
+    pass
+
+
+class FetchDownloadsAction(BaseAction):
+    """
+    获取下载任务
+    """
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self._downloads = []
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "获取下载任务"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "获取下载队列中的任务状态"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return FetchDownloadsParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return self.done
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        更新downloads中的下载任务状态
+        """
+        __all_complete = False
+        for download in self._downloads:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            logger.info(f"获取下载任务 {download.download_id} 状态 ...")
+            torrents = ActionChain().list_torrents(hashs=[download.download_id])
+            if not torrents:
+                download.completed = True
+                continue
+            for t in torrents:
+                download.path = t.path
+                if t.progress >= 100:
+                    logger.info(f"下载任务 {download.download_id} 已完成")
+                    download.completed = True
+                else:
+                    logger.info(f"下载任务 {download.download_id} 未完成")
+                    download.completed = False
+        if all([d.completed for d in self._downloads]):
+            self.job_done()
+        return context

app/actions/fetch_medias.py

@@ -0,0 +1,186 @@
+from typing import List, Optional
+
+from pydantic import Field
+
+from app.actions import BaseAction
+from app.chain.recommend import RecommendChain
+from app.schemas import ActionParams, ActionContext
+from app.core.config import settings, global_vars
+from app.core.event import eventmanager
+from app.log import logger
+from app.schemas import RecommendSourceEventData, MediaInfo
+from app.schemas.types import ChainEventType
+from app.utils.http import RequestUtils
+
+
+class FetchMediasParams(ActionParams):
+    """
+    获取媒体数据参数
+    """
+    source_type: Optional[str] = Field(default="ranking", description="来源")
+    sources: Optional[List[str]] = Field(default=[], description="榜单")
+    api_path: Optional[str] = Field(default=None, description="API路径")
+
+
+class FetchMediasAction(BaseAction):
+    """
+    获取媒体数据
+    """
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+
+        self._medias = []
+        self._has_error = False
+        self.__inner_sources = [
+            {
+                "func": RecommendChain().tmdb_trending,
+                "name": '流行趋势',
+                "api_path": "recommend/tmdb_trending"
+            },
+            {
+                "func": RecommendChain().douban_movie_showing,
+                "name": '正在热映',
+                "api_path": "recommend/douban_showing"
+            },
+            {
+                "func": RecommendChain().bangumi_calendar,
+                "name": 'Bangumi每日放送',
+                "api_path": "recommend/bangumi_calendar"
+            },
+            {
+                "func": RecommendChain().tmdb_movies,
+                "name": 'TMDB热门电影',
+                "api_path": "recommend/tmdb_movies"
+            },
+            {
+                "func": RecommendChain().tmdb_tvs,
+                "name": 'TMDB热门电视剧',
+                "api_path": "recommend/tmdb_tvs?with_original_language=zh|en|ja|ko"
+            },
+            {
+                "func": RecommendChain().douban_movie_hot,
+                "name": '豆瓣热门电影',
+                "api_path": "recommend/douban_movie_hot"
+            },
+            {
+                "func": RecommendChain().douban_tv_hot,
+                "name": '豆瓣热门电视剧',
+                "api_path": "recommend/douban_tv_hot"
+            },
+            {
+                "func": RecommendChain().douban_tv_animation,
+                "name": '豆瓣热门动漫',
+                "api_path": "recommend/douban_tv_animation"
+            },
+            {
+                "func": RecommendChain().douban_movies,
+                "name": '豆瓣最新电影',
+                "api_path": "recommend/douban_movies"
+            },
+            {
+                "func": RecommendChain().douban_tvs,
+                "name": '豆瓣最新电视剧',
+                "api_path": "recommend/douban_tvs"
+            },
+            {
+                "func": RecommendChain().douban_movie_top250,
+                "name": '豆瓣电影TOP250',
+                "api_path": "recommend/douban_movie_top250"
+            },
+            {
+                "func": RecommendChain().douban_tv_weekly_chinese,
+                "name": '豆瓣国产剧集榜',
+                "api_path": "recommend/douban_tv_weekly_chinese"
+            },
+            {
+                "func": RecommendChain().douban_tv_weekly_global,
+                "name": '豆瓣全球剧集榜',
+                "api_path": "recommend/douban_tv_weekly_global"
+            }
+        ]
+
+        # 广播事件，请示额外的推荐数据源支持
+        event_data = RecommendSourceEventData()
+        event = eventmanager.send_event(ChainEventType.RecommendSource, event_data)
+        # 使用事件返回的上下文数据
+        if event and event.event_data:
+            event_data: RecommendSourceEventData = event.event_data
+            if event_data.extra_sources:
+                self.__inner_sources.extend([s.dict() for s in event_data.extra_sources])
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "获取媒体数据"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "获取榜单等媒体数据列表"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return FetchMediasParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return not self._has_error
+
+    def __get_source(self, source: str):
+        """
+        获取数据源
+        """
+        for s in self.__inner_sources:
+            if s['api_path'] == source:
+                return s
+        return None
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        获取媒体数据，填充到medias
+        """
+        params = FetchMediasParams(**params)
+        try:
+            if params.source_type == "ranking":
+                for api_path in params.sources:
+                    if global_vars.is_workflow_stopped(workflow_id):
+                        break
+                    source = self.__get_source(api_path)
+                    if not source:
+                        continue
+                    logger.info(f"获取媒体数据 {source} ...")
+                    name = source.get("name")
+                    results = []
+                    if source.get("func"):
+                        results = source['func']()
+                    else:
+                        # 调用内部API获取数据
+                        api_url = f"http://127.0.0.1:{settings.PORT}/api/v1/{source['api_path']}?token={settings.API_TOKEN}"
+                        res = RequestUtils(timeout=15).post_res(api_url)
+                        if res:
+                            results = res.json()
+                    if results:
+                        logger.info(f"{name} 获取到 {len(results)} 条数据")
+                        self._medias.extend([MediaInfo(**r) for r in results])
+                    else:
+                        logger.error(f"{name} 获取数据失败")
+            else:
+                # 调用内部API获取数据
+                api_url = f"http://127.0.0.1:{settings.PORT}{params.api_path}?token={settings.API_TOKEN}"
+                res = RequestUtils(timeout=15).post_res(api_url)
+                if res:
+                    results = res.json()
+                    if results:
+                        logger.info(f"{params.api_path} 获取到 {len(results)} 条数据")
+                        self._medias.extend([MediaInfo(**r) for r in results])
+        except Exception as e:
+            logger.error(f"获取媒体数据失败: {e}")
+            self._has_error = True
+
+        if self._medias:
+            context.medias.extend(self._medias)
+
+        self.job_done(f"获取到 {len(self._medias)} 条媒数据")
+        return context

app/actions/fetch_rss.py

@@ -0,0 +1,112 @@
+from typing import Optional
+
+from pydantic import Field
+
+from app.actions import BaseAction, ActionChain
+from app.core.config import settings, global_vars
+from app.core.context import Context
+from app.core.metainfo import MetaInfo
+from app.helper.rss import RssHelper
+from app.log import logger
+from app.schemas import ActionParams, ActionContext, TorrentInfo
+
+
+class FetchRssParams(ActionParams):
+    """
+    获取RSS资源列表参数
+    """
+    url: str = Field(default=None, description="RSS地址")
+    proxy: Optional[bool] = Field(default=False, description="是否使用代理")
+    timeout: Optional[int] = Field(default=15, description="超时时间")
+    content_type: Optional[str] = Field(default=None, description="Content-Type")
+    referer: Optional[str] = Field(default=None, description="Referer")
+    ua: Optional[str] = Field(default=None, description="User-Agent")
+    match_media: Optional[str] = Field(default=None, description="匹配媒体信息")
+
+
+class FetchRssAction(BaseAction):
+    """
+    获取RSS资源列表
+    """
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self._rss_torrents = []
+        self._has_error = False
+
+    @classmethod
+    @property
+    def name(cls) -> str:  # noqa
+        return "获取RSS资源"
+
+    @classmethod
+    @property
+    def description(cls) -> str:  # noqa
+        return "订阅RSS地址获取资源"
+
+    @classmethod
+    @property
+    def data(cls) -> dict:  # noqa
+        return FetchRssParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return not self._has_error
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        请求RSS地址获取数据，并解析为资源列表
+        """
+        params = FetchRssParams(**params)
+        if not params.url:
+            return context
+
+        headers = {}
+        if params.content_type:
+            headers["Content-Type"] = params.content_type
+        if params.referer:
+            headers["Referer"] = params.referer
+        if params.ua:
+            headers["User-Agent"] = params.ua
+
+        rss_items = RssHelper().parse(url=params.url,
+                                      proxy=settings.PROXY if params.proxy else None,
+                                      timeout=params.timeout,
+                                      headers=headers)
+        if rss_items is None or rss_items is False:
+            logger.error(f'RSS地址 {params.url} 请求失败！')
+            self._has_error = True
+            return context
+
+        if not rss_items:
+            logger.error(f'RSS地址 {params.url} 未获取到RSS数据！')
+            return context
+
+        # 组装种子
+        for item in rss_items:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            if not item.get("title"):
+                continue
+            torrentinfo = TorrentInfo(
+                title=item.get("title"),
+                enclosure=item.get("enclosure"),
+                page_url=item.get("link"),
+                size=item.get("size"),
+                pubdate=item["pubdate"].strftime("%Y-%m-%d %H:%M:%S") if item.get("pubdate") else None,
+            )
+            meta = MetaInfo(title=torrentinfo.title, subtitle=torrentinfo.description)
+            mediainfo = None
+            if params.match_media:
+                mediainfo = ActionChain().recognize_media(meta)
+                if not mediainfo:
+                    logger.warning(f"{torrentinfo.title} 未识别到媒体信息")
+                    continue
+            self._rss_torrents.append(Context(meta_info=meta, media_info=mediainfo, torrent_info=torrentinfo))
+
+        if self._rss_torrents:
+            logger.info(f"获取到 {len(self._rss_torrents)} 个RSS资源")
+            context.torrents.extend(self._rss_torrents)
+
+        self.job_done(f"获取到 {len(self._rss_torrents)} 个资源")
+        return context

app/actions/fetch_torrents.py

@@ -0,0 +1,102 @@
+import random
+import time
+from typing import Optional, List
+
+from pydantic import Field
+
+from app.actions import BaseAction
+from app.chain.search import SearchChain
+from app.core.config import global_vars
+from app.log import logger
+from app.schemas import ActionParams, ActionContext, MediaType
+
+
+class FetchTorrentsParams(ActionParams):
+    """
+    获取站点资源参数
+    """
+    search_type: Optional[str] = Field(default="keyword", description="搜索类型")
+    name: Optional[str] = Field(default=None, description="资源名称")
+    year: Optional[str] = Field(default=None, description="年份")
+    type: Optional[str] = Field(default=None, description="资源类型 (电影/电视剧)")
+    season: Optional[int] = Field(default=None, description="季度")
+    sites: Optional[List[int]] = Field(default=[], description="站点列表")
+    match_media: Optional[bool] = Field(default=False, description="匹配媒体信息")
+
+
+class FetchTorrentsAction(BaseAction):
+    """
+    搜索站点资源
+    """
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self._torrents = []
+
+    @classmethod
+    @property
+    def name(cls) -> str:  # noqa
+        return "搜索站点资源"
+
+    @classmethod
+    @property
+    def description(cls) -> str:  # noqa
+        return "搜索站点种子资源列表"
+
+    @classmethod
+    @property
+    def data(cls) -> dict:  # noqa
+        return FetchTorrentsParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return self.done
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        搜索站点，获取资源列表
+        """
+        params = FetchTorrentsParams(**params)
+        searchchain = SearchChain()
+        if params.search_type == "keyword":
+            # 按关键字搜索
+            torrents = searchchain.search_by_title(title=params.name, sites=params.sites)
+            for torrent in torrents:
+                if global_vars.is_workflow_stopped(workflow_id):
+                    break
+                if params.year and torrent.meta_info.year != params.year:
+                    continue
+                if params.type and torrent.media_info and torrent.media_info.type != MediaType(params.type):
+                    continue
+                if params.season and torrent.meta_info.begin_season != params.season:
+                    continue
+                # 识别媒体信息
+                if params.match_media:
+                    torrent.media_info = searchchain.recognize_media(torrent.meta_info)
+                    if not torrent.media_info:
+                        logger.warning(f"{torrent.torrent_info.title} 未识别到媒体信息")
+                        continue
+                self._torrents.append(torrent)
+        else:
+            # 搜索媒体列表
+            for media in context.medias:
+                if global_vars.is_workflow_stopped(workflow_id):
+                    break
+                torrents = searchchain.search_by_id(tmdbid=media.tmdb_id,
+                                                    doubanid=media.douban_id,
+                                                    mtype=MediaType(media.type),
+                                                    sites=params.sites)
+                for torrent in torrents:
+                    self._torrents.append(torrent)
+
+                # 随机休眠 5-30秒
+                sleep_time = random.randint(5, 30)
+                logger.info(f"随机休眠 {sleep_time} 秒 ...")
+                time.sleep(sleep_time)
+
+        if self._torrents:
+            context.torrents.extend(self._torrents)
+            logger.info(f"共搜索到 {len(self._torrents)} 条资源")
+
+        self.job_done(f"搜索到 {len(self._torrents)} 个资源")
+        return context

app/actions/filter_medias.py

@@ -0,0 +1,69 @@
+from typing import Optional
+
+from pydantic import Field
+
+from app.actions import BaseAction
+from app.core.config import global_vars
+from app.log import logger
+from app.schemas import ActionParams, ActionContext
+
+
+class FilterMediasParams(ActionParams):
+    """
+    过滤媒体数据参数
+    """
+    type: Optional[str] = Field(default=None, description="媒体类型 (电影/电视剧)")
+    vote: Optional[int] = Field(default=0, description="评分")
+    year: Optional[str] = Field(default=None, description="年份")
+
+
+class FilterMediasAction(BaseAction):
+    """
+    过滤媒体数据
+    """
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self._medias = []
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "过滤媒体数据"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "对媒体数据列表进行过滤"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return FilterMediasParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return self.done
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        过滤medias中媒体数据
+        """
+        params = FilterMediasParams(**params)
+        for media in context.medias:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            if params.type and media.type != params.type:
+                continue
+            if params.vote and media.vote_average < params.vote:
+                continue
+            if params.year and media.year != params.year:
+                continue
+            self._medias.append(media)
+
+        logger.info(f"过滤后剩余 {len(self._medias)} 条媒体数据")
+
+        context.medias = self._medias
+
+        self.job_done(f"过滤后剩余 {len(self._medias)} 条媒体数据")
+        return context

app/actions/filter_torrents.py

@@ -0,0 +1,84 @@
+from typing import Optional, List
+
+from pydantic import Field
+
+from app.actions import BaseAction, ActionChain
+from app.core.config import global_vars
+from app.helper.torrent import TorrentHelper
+from app.log import logger
+from app.schemas import ActionParams, ActionContext
+
+
+class FilterTorrentsParams(ActionParams):
+    """
+    过滤资源数据参数
+    """
+    rule_groups: Optional[List[str]] = Field(default=[], description="规则组")
+    quality: Optional[str] = Field(default=None, description="资源质量")
+    resolution: Optional[str] = Field(default=None, description="资源分辨率")
+    effect: Optional[str] = Field(default=None, description="特效")
+    include: Optional[str] = Field(default=None, description="包含规则")
+    exclude: Optional[str] = Field(default=None, description="排除规则")
+    size: Optional[str] = Field(default=None, description="资源大小范围（MB）")
+
+
+class FilterTorrentsAction(BaseAction):
+    """
+    过滤资源数据
+    """
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self._torrents = []
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "过滤资源"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "对资源列表数据进行过滤"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return FilterTorrentsParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return self.done
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        过滤torrents中的资源
+        """
+        params = FilterTorrentsParams(**params)
+        for torrent in context.torrents:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            if TorrentHelper().filter_torrent(
+                    torrent_info=torrent.torrent_info,
+                    filter_params={
+                        "quality": params.quality,
+                        "resolution": params.resolution,
+                        "effect": params.effect,
+                        "include": params.include,
+                        "exclude": params.exclude,
+                        "size": params.size
+                    }
+            ):
+                if ActionChain().filter_torrents(
+                        rule_groups=params.rule_groups,
+                        torrent_list=[torrent.torrent_info],
+                        mediainfo=torrent.media_info
+                ):
+                    self._torrents.append(torrent)
+
+        logger.info(f"过滤后剩余 {len(self._torrents)} 个资源")
+
+        context.torrents = self._torrents
+
+        self.job_done(f"过滤后剩余 {len(self._torrents)} 个资源")
+        return context

app/actions/invoke_plugin.py

@@ -0,0 +1,70 @@
+from pydantic import Field
+
+from app.actions import BaseAction
+from app.core.plugin import PluginManager
+from app.log import logger
+from app.schemas import ActionParams, ActionContext
+
+
+class InvokePluginParams(ActionParams):
+    """
+    调用插件动作参数
+    """
+    plugin_id: str = Field(default=None, description="插件ID")
+    action_id: str = Field(default=None, description="动作ID")
+    action_params: dict = Field(default={}, description="动作参数")
+
+
+class InvokePluginAction(BaseAction):
+    """
+    调用插件
+    """
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self._success = False
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "调用插件"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "调用插件提供的动作"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return InvokePluginParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return self._success
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        执行插件定义的动作
+        """
+        params = InvokePluginParams(**params)
+        if not params.plugin_id or not params.action_id:
+            return context
+        try:
+            plugin_actions = PluginManager().get_plugin_actions(params.plugin_id)
+            if not plugin_actions:
+                logger.error(f"插件不存在: {params.plugin_id}")
+                return context
+            actions = plugin_actions[0].get("actions", [])
+            action = next((action for action in actions if action.action_id == params.action_id), None)
+            if not action or not action.get("func"):
+                logger.error(f"插件动作不存在: {params.plugin_id} - {params.action_id}")
+                return context
+            # 执行插件动作
+            self._success, context = action["func"](context, **params.action_params)
+        except Exception as e:
+            self._success = False
+            logger.error(f"调用插件动作失败: {e}")
+            return context
+        self.job_done()
+        return context

app/actions/scan_file.py

@@ -0,0 +1,83 @@
+from pathlib import Path
+from typing import Optional
+
+from pydantic import Field
+
+from app.actions import BaseAction
+from app.chain.storage import StorageChain
+from app.core.config import global_vars, settings
+from app.log import logger
+from app.schemas import ActionParams, ActionContext
+
+
+class ScanFileParams(ActionParams):
+    """
+    整理文件参数
+    """
+    # 存储
+    storage: Optional[str] = Field(default="local", description="存储")
+    directory: Optional[str] = Field(default=None, description="目录")
+
+
+class ScanFileAction(BaseAction):
+    """
+    整理文件
+    """
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self._fileitems = []
+        self._has_error = False
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "扫描目录"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "扫描目录文件到队列"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return ScanFileParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return not self._has_error
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        扫描目录中的所有文件，记录到fileitems
+        """
+        params = ScanFileParams(**params)
+        if not params.storage or not params.directory:
+            return context
+        storagechain = StorageChain()
+        fileitem = storagechain.get_file_item(params.storage, Path(params.directory))
+        if not fileitem:
+            logger.error(f"目录不存在: 【{params.storage}】{params.directory}")
+            self._has_error = True
+            return context
+        files = storagechain.list_files(fileitem, recursion=True)
+        for file in files:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            if not file.extension or f".{file.extension.lower()}" not in settings.RMT_MEDIAEXT:
+                continue
+            # 检查缓存
+            cache_key = f"{file.path}"
+            if self.check_cache(workflow_id, cache_key):
+                logger.info(f"{file.path} 已处理过，跳过")
+                continue
+            self._fileitems.append(fileitem)
+            # 保存缓存
+            self.save_cache(workflow_id, cache_key)
+
+        if self._fileitems:
+            context.fileitems.extend(self._fileitems)
+
+        self.job_done(f"扫描到 {len(self._fileitems)} 个文件")
+        return context

app/actions/scrape_file.py

@@ -0,0 +1,82 @@
+from pathlib import Path
+
+from app.actions import BaseAction
+from app.core.config import global_vars
+from app.schemas import ActionParams, ActionContext
+from app.chain.media import MediaChain
+from app.chain.storage import StorageChain
+from app.core.metainfo import MetaInfoPath
+from app.log import logger
+
+
+class ScrapeFileParams(ActionParams):
+    """
+    刮削文件参数
+    """
+    pass
+
+
+class ScrapeFileAction(BaseAction):
+    """
+    刮削文件
+    """
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self._scraped_files = []
+        self._has_error = False
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "刮削文件"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "刮削媒体信息和图片"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return ScrapeFileParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return not self._has_error
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        刮削fileitems中的所有文件
+        """
+        # 失败次数
+        _failed_count = 0
+        for fileitem in context.fileitems:
+            if global_vars.is_workflow_stopped(workflow_id):
+                break
+            if fileitem in self._scraped_files:
+                continue
+            if not StorageChain().exists(fileitem):
+                continue
+            # 检查缓存
+            cache_key = f"{fileitem.path}"
+            if self.check_cache(workflow_id, cache_key):
+                logger.info(f"{fileitem.path} 已刮削过，跳过")
+                continue
+            meta = MetaInfoPath(Path(fileitem.path))
+            mediachain = MediaChain()
+            mediainfo = mediachain.recognize_media(meta)
+            if not mediainfo:
+                _failed_count += 1
+                logger.info(f"{fileitem.path} 未识别到媒体信息，无法刮削")
+                continue
+            mediachain.scrape_metadata(fileitem=fileitem, meta=meta, mediainfo=mediainfo)
+            self._scraped_files.append(fileitem)
+            # 保存缓存
+            self.save_cache(workflow_id, cache_key)
+
+        if not self._scraped_files and _failed_count:
+            self._has_error = True
+
+        self.job_done(f"成功刮削 {len(self._scraped_files)} 个文件，失败 {_failed_count} 个")
+        return context

app/actions/send_event.py

@@ -0,0 +1,48 @@
+from app.actions import BaseAction
+from app.core.event import eventmanager
+from app.schemas import ActionParams, ActionContext
+from app.schemas.types import ChainEventType
+
+
+class SendEventParams(ActionParams):
+    """
+    发送事件参数
+    """
+    pass
+
+
+class SendEventAction(BaseAction):
+    """
+    发送事件
+    """
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "发送事件"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "发送任务执行事件"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return SendEventParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return self.done
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        发送工作流事件，以更插件干预工作流执行
+        """
+        # 触发资源下载事件，更新执行上下文
+        event = eventmanager.send_event(ChainEventType.WorkflowExecution, context)
+        if event and event.event_data:
+            context = event.event_data
+
+        self.job_done()
+        return context

app/actions/send_message.py

@@ -0,0 +1,73 @@
+from typing import List, Optional, Union
+
+from pydantic import Field
+
+from app.actions import BaseAction, ActionChain
+from app.schemas import ActionParams, ActionContext, Notification
+from app.core.config import settings
+
+
+class SendMessageParams(ActionParams):
+    """
+    发送消息参数
+    """
+    client: Optional[List[str]] = Field(default=[], description="消息渠道")
+    userid: Optional[Union[str, int]] = Field(default=None, description="用户ID")
+
+
+class SendMessageAction(BaseAction):
+    """
+    发送消息
+    """
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+
+    @classmethod
+    @property
+    def name(cls) -> str: # noqa
+        return "发送消息"
+
+    @classmethod
+    @property
+    def description(cls) -> str: # noqa
+        return "发送任务执行消息"
+
+    @classmethod
+    @property
+    def data(cls) -> dict: # noqa
+        return SendMessageParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return self.done
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        发送messages中的消息
+        """
+        params = SendMessageParams(**params)
+        msg_text = f"当前进度：{context.progress}%"
+        index = 1
+        if context.execute_history:
+            for history in context.execute_history:
+                if not history.message:
+                    continue
+                msg_text += f"\n{index}. {history.action}：{history.message}"
+                index += 1
+            # 发送消息
+            if not params.client:
+                params.client = [""]
+            for client in params.client:
+                ActionChain().post_message(
+                    Notification(
+                        source=client,
+                        userid=params.userid,
+                        title="【工作流执行结果】",
+                        text=msg_text,
+                        link=settings.MP_DOMAIN("#/workflow")
+                    )
+                )
+
+        self.job_done()
+        return context

app/actions/transfer_file.py

@@ -0,0 +1,136 @@
+import copy
+from pathlib import Path
+from typing import Optional
+
+from pydantic import Field
+
+from app.actions import BaseAction
+from app.core.config import global_vars
+from app.db.transferhistory_oper import TransferHistoryOper
+from app.schemas import ActionParams, ActionContext
+from app.chain.storage import StorageChain
+from app.chain.transfer import TransferChain
+from app.log import logger
+
+
+class TransferFileParams(ActionParams):
+    """
+    整理文件参数
+    """
+    # 来源
+    source: Optional[str] = Field(default="downloads", description="来源")
+
+
+class TransferFileAction(BaseAction):
+    """
+    整理文件
+    """
+
+    def __init__(self, action_id: str):
+        super().__init__(action_id)
+        self._fileitems = []
+        self._has_error = False
+
+    @classmethod
+    @property
+    def name(cls) -> str:  # noqa
+        return "整理文件"
+
+    @classmethod
+    @property
+    def description(cls) -> str:  # noqa
+        return "整理队列中的文件"
+
+    @classmethod
+    @property
+    def data(cls) -> dict:  # noqa
+        return TransferFileParams().dict()
+
+    @property
+    def success(self) -> bool:
+        return not self._has_error
+
+    def execute(self, workflow_id: int, params: dict, context: ActionContext) -> ActionContext:
+        """
+        从 downloads / fileitems 中整理文件，记录到fileitems
+        """
+
+        def check_continue():
+            """
+            检查是否继续整理文件
+            """
+            if global_vars.is_workflow_stopped(workflow_id):
+                return False
+            return True
+
+        params = TransferFileParams(**params)
+        # 失败次数
+        _failed_count = 0
+        storagechain = StorageChain()
+        transferchain = TransferChain()
+        transferhis = TransferHistoryOper()
+        if params.source == "downloads":
+            # 从下载任务中整理文件
+            for download in context.downloads:
+                if global_vars.is_workflow_stopped(workflow_id):
+                    break
+                if not download.completed:
+                    logger.info(f"下载任务 {download.download_id} 未完成")
+                    continue
+                # 检查缓存
+                cache_key = f"{download.download_id}"
+                if self.check_cache(workflow_id, cache_key):
+                    logger.info(f"{download.path} 已整理过，跳过")
+                    continue
+                fileitem = storagechain.get_file_item(storage="local", path=Path(download.path))
+                if not fileitem:
+                    logger.info(f"文件 {download.path} 不存在")
+                    continue
+                transferd = transferhis.get_by_src(fileitem.path, storage=fileitem.storage)
+                if transferd:
+                    # 已经整理过的文件不再整理
+                    continue
+                logger.info(f"开始整理文件 {download.path} ...")
+                state, errmsg = transferchain.do_transfer(fileitem, background=False)
+                if not state:
+                    _failed_count += 1
+                    logger.error(f"整理文件 {download.path} 失败: {errmsg}")
+                    continue
+                logger.info(f"整理文件 {download.path} 完成")
+                self._fileitems.append(fileitem)
+                self.save_cache(workflow_id, cache_key)
+        else:
+            # 从 fileitems 中整理文件
+            for fileitem in copy.deepcopy(context.fileitems):
+                if not check_continue():
+                    break
+                # 检查缓存
+                cache_key = f"{fileitem.path}"
+                if self.check_cache(workflow_id, cache_key):
+                    logger.info(f"{fileitem.path} 已整理过，跳过")
+                    continue
+                transferd = transferhis.get_by_src(fileitem.path, storage=fileitem.storage)
+                if transferd:
+                    # 已经整理过的文件不再整理
+                    continue
+                logger.info(f"开始整理文件 {fileitem.path} ...")
+                state, errmsg = transferchain.do_transfer(fileitem, background=False,
+                                                          continue_callback=check_continue)
+                if not state:
+                    _failed_count += 1
+                    logger.error(f"整理文件 {fileitem.path} 失败: {errmsg}")
+                    continue
+                logger.info(f"整理文件 {fileitem.path} 完成")
+                # 从 fileitems 中移除已整理的文件
+                context.fileitems.remove(fileitem)
+                self._fileitems.append(fileitem)
+                # 记录已整理的文件
+                self.save_cache(workflow_id, cache_key)
+
+        if self._fileitems:
+            context.fileitems.extend(self._fileitems)
+        elif _failed_count:
+            self._has_error = True
+
+        self.job_done(f"整理成功 {len(self._fileitems)} 个文件，失败 {_failed_count} 个")
+        return context

app/api/apiv1.py

@@ -1,7 +1,8 @@
 from fastapi import APIRouter
 
 from app.api.endpoints import login, user, site, message, webhook, subscribe, \
-    media, douban, search, plugin, tmdb, history, system, download, dashboard, filebrowser, transfer
+    media, douban, search, plugin, tmdb, history, system, download, dashboard, \
+    transfer, mediaserver, bangumi, storage, discover, recommend, workflow, torrent
 
 api_router = APIRouter()
 api_router.include_router(login.router, prefix="/login", tags=["login"])
@@ -19,5 +20,11 @@ api_router.include_router(system.router, prefix="/system", tags=["system"])
 api_router.include_router(plugin.router, prefix="/plugin", tags=["plugin"])
 api_router.include_router(download.router, prefix="/download", tags=["download"])
 api_router.include_router(dashboard.router, prefix="/dashboard", tags=["dashboard"])
-api_router.include_router(filebrowser.router, prefix="/filebrowser", tags=["filebrowser"])
+api_router.include_router(storage.router, prefix="/storage", tags=["storage"])
 api_router.include_router(transfer.router, prefix="/transfer", tags=["transfer"])
+api_router.include_router(mediaserver.router, prefix="/mediaserver", tags=["mediaserver"])
+api_router.include_router(bangumi.router, prefix="/bangumi", tags=["bangumi"])
+api_router.include_router(discover.router, prefix="/discover", tags=["discover"])
+api_router.include_router(recommend.router, prefix="/recommend", tags=["recommend"])
+api_router.include_router(workflow.router, prefix="/workflow", tags=["workflow"])
+api_router.include_router(torrent.router, prefix="/torrent", tags=["torrent"])

app/api/endpoints/bangumi.py

@@ -0,0 +1,74 @@
+from typing import List, Any, Optional
+
+from fastapi import APIRouter, Depends
+
+from app import schemas
+from app.chain.bangumi import BangumiChain
+from app.core.context import MediaInfo
+from app.core.security import verify_token
+
+router = APIRouter()
+
+
+@router.get("/credits/{bangumiid}", summary="查询Bangumi演职员表", response_model=List[schemas.MediaPerson])
+def bangumi_credits(bangumiid: int,
+                    page: Optional[int] = 1,
+                    count: Optional[int] = 20,
+                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询Bangumi演职员表
+    """
+    persons = BangumiChain().bangumi_credits(bangumiid)
+    if persons:
+        return persons[(page - 1) * count: page * count]
+    return []
+
+
+@router.get("/recommend/{bangumiid}", summary="查询Bangumi推荐", response_model=List[schemas.MediaInfo])
+def bangumi_recommend(bangumiid: int,
+                      page: Optional[int] = 1,
+                      count: Optional[int] = 20,
+                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询Bangumi推荐
+    """
+    medias = BangumiChain().bangumi_recommend(bangumiid)
+    if medias:
+        return [media.to_dict() for media in medias[(page - 1) * count: page * count]]
+    return []
+
+
+@router.get("/person/{person_id}", summary="人物详情", response_model=schemas.MediaPerson)
+def bangumi_person(person_id: int,
+                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据人物ID查询人物详情
+    """
+    return BangumiChain().person_detail(person_id=person_id)
+
+
+@router.get("/person/credits/{person_id}", summary="人物参演作品", response_model=List[schemas.MediaInfo])
+def bangumi_person_credits(person_id: int,
+                           page: Optional[int] = 1,
+                           count: Optional[int] = 20,
+                           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据人物ID查询人物参演作品
+    """
+    medias = BangumiChain().person_credits(person_id=person_id)
+    if medias:
+        return [media.to_dict() for media in medias[(page - 1) * count: page * count]]
+    return []
+
+
+@router.get("/{bangumiid}", summary="查询Bangumi详情", response_model=schemas.MediaInfo)
+def bangumi_info(bangumiid: int,
+                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询Bangumi详情
+    """
+    info = BangumiChain().bangumi_info(bangumiid)
+    if info:
+        return MediaInfo(bangumi_info=info).to_dict()
+    else:
+        return schemas.MediaInfo()

app/api/endpoints/dashboard.py

@@ -1,15 +1,16 @@
 from pathlib import Path
-from typing import Any, List, Optional
+from typing import Any, List, Optional, Annotated
 
 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 
 from app import schemas
 from app.chain.dashboard import DashboardChain
-from app.core.config import settings
-from app.core.security import verify_token
+from app.chain.storage import StorageChain
+from app.core.security import verify_token, verify_apitoken
 from app.db import get_db
 from app.db.models.transferhistory import TransferHistory
+from app.helper.directory import DirectoryHelper
 from app.scheduler import Scheduler
 from app.utils.system import SystemUtils
 
@@ -17,12 +18,11 @@ router = APIRouter()
 
 
 @router.get("/statistic", summary="媒体数量统计", response_model=schemas.Statistic)
-def statistic(db: Session = Depends(get_db),
-              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def statistic(name: Optional[str] = None, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询媒体数量统计信息
     """
-    media_statistics: Optional[List[schemas.Statistic]] = DashboardChain(db).media_statistic()
+    media_statistics: Optional[List[schemas.Statistic]] = DashboardChain().media_statistic(name)
     if media_statistics:
         # 汇总各媒体库统计信息
         ret_statistic = schemas.Statistic()
@@ -36,18 +36,43 @@ def statistic(db: Session = Depends(get_db),
         return schemas.Statistic()
 
 
-@router.get("/storage", summary="存储空间", response_model=schemas.Storage)
+@router.get("/statistic2", summary="媒体数量统计（API_TOKEN）", response_model=schemas.Statistic)
+def statistic2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    查询媒体数量统计信息 API_TOKEN认证（?token=xxx）
+    """
+    return statistic()
+
+
+@router.get("/storage", summary="本地存储空间", response_model=schemas.Storage)
 def storage(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    查询存储空间信息
+    查询本地存储空间信息
     """
-    total_storage, free_storage = SystemUtils.space_usage(settings.LIBRARY_PATHS)
+    total, available = 0, 0
+    dirs = DirectoryHelper().get_dirs()
+    if not dirs:
+        return schemas.Storage(total_storage=total, used_storage=total - available)
+    storages = set([d.library_storage for d in dirs if d.library_storage])
+    for _storage in storages:
+        _usage = StorageChain().storage_usage(_storage)
+        if _usage:
+            total += _usage.total
+            available += _usage.available
     return schemas.Storage(
-        total_storage=total_storage,
-        used_storage=total_storage - free_storage
+        total_storage=total,
+        used_storage=total - available
     )
 
 
+@router.get("/storage2", summary="本地存储空间（API_TOKEN）", response_model=schemas.Storage)
+def storage2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    查询本地存储空间信息 API_TOKEN认证（?token=xxx）
+    """
+    return storage()
+
+
 @router.get("/processes", summary="进程信息", response_model=List[schemas.ProcessInfo])
 def processes(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
@@ -57,23 +82,32 @@ def processes(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
 
 
 @router.get("/downloader", summary="下载器信息", response_model=schemas.DownloaderInfo)
-def downloader(db: Session = Depends(get_db),
-               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def downloader(name: Optional[str] = None, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询下载器信息
     """
-    transfer_info = DashboardChain(db).downloader_info()
-    free_space = SystemUtils.free_space(Path(settings.DOWNLOAD_PATH))
-    if transfer_info:
-        return schemas.DownloaderInfo(
-            download_speed=transfer_info.download_speed,
-            upload_speed=transfer_info.upload_speed,
-            download_size=transfer_info.download_size,
-            upload_size=transfer_info.upload_size,
-            free_space=free_space
-        )
-    else:
-        return schemas.DownloaderInfo()
+    # 下载目录空间
+    download_dirs = DirectoryHelper().get_local_download_dirs()
+    _, free_space = SystemUtils.space_usage([Path(d.download_path) for d in download_dirs])
+    # 下载器信息
+    downloader_info = schemas.DownloaderInfo()
+    transfer_infos = DashboardChain().downloader_info(name)
+    if transfer_infos:
+        for transfer_info in transfer_infos:
+            downloader_info.download_speed += transfer_info.download_speed
+            downloader_info.upload_speed += transfer_info.upload_speed
+            downloader_info.download_size += transfer_info.download_size
+            downloader_info.upload_size += transfer_info.upload_size
+        downloader_info.free_space = free_space
+    return downloader_info
+
+
+@router.get("/downloader2", summary="下载器信息（API_TOKEN）", response_model=schemas.DownloaderInfo)
+def downloader2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    查询下载器信息 API_TOKEN认证（?token=xxx）
+    """
+    return downloader()
 
 
 @router.get("/schedule", summary="后台服务", response_model=List[schemas.ScheduleInfo])
@@ -84,8 +118,16 @@ def schedule(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     return Scheduler().list()
 
 
+@router.get("/schedule2", summary="后台服务（API_TOKEN）", response_model=List[schemas.ScheduleInfo])
+def schedule2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    查询下载器信息 API_TOKEN认证（?token=xxx）
+    """
+    return schedule()
+
+
 @router.get("/transfer", summary="文件整理统计", response_model=List[int])
-def transfer(days: int = 7, db: Session = Depends(get_db),
+def transfer(days: Optional[int] = 7, db: Session = Depends(get_db),
              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询文件整理统计信息
@@ -102,9 +144,25 @@ def cpu(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     return SystemUtils.cpu_usage()
 
 
+@router.get("/cpu2", summary="获取当前CPU使用率（API_TOKEN）", response_model=int)
+def cpu2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    获取当前CPU使用率 API_TOKEN认证（?token=xxx）
+    """
+    return cpu()
+
+
 @router.get("/memory", summary="获取当前内存使用量和使用率", response_model=List[int])
 def memory(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     获取当前内存使用率
     """
     return SystemUtils.memory_usage()
+
+
+@router.get("/memory2", summary="获取当前内存使用量和使用率（API_TOKEN）", response_model=List[int])
+def memory2(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    获取当前内存使用率 API_TOKEN认证（?token=xxx）
+    """
+    return memory()

app/api/endpoints/discover.py

@@ -0,0 +1,130 @@
+from typing import Any, List, Optional
+
+from fastapi import APIRouter, Depends
+
+from app import schemas
+from app.core.event import eventmanager
+from app.core.security import verify_token
+from app.schemas import DiscoverSourceEventData
+from app.schemas.types import ChainEventType, MediaType
+from app.chain.bangumi import BangumiChain
+from app.chain.douban import DoubanChain
+from app.chain.tmdb import TmdbChain
+
+router = APIRouter()
+
+
+@router.get("/source", summary="获取探索数据源", response_model=List[schemas.DiscoverMediaSource])
+def source(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    获取探索数据源
+    """
+    # 广播事件，请示额外的探索数据源支持
+    event_data = DiscoverSourceEventData()
+    event = eventmanager.send_event(ChainEventType.DiscoverSource, event_data)
+    # 使用事件返回的上下文数据
+    if event and event.event_data:
+        event_data: DiscoverSourceEventData = event.event_data
+        if event_data.extra_sources:
+            return event_data.extra_sources
+    return []
+
+
+@router.get("/bangumi", summary="探索Bangumi", response_model=List[schemas.MediaInfo])
+def bangumi(type: Optional[int] = 2,
+            cat: Optional[int] = None,
+            sort: Optional[str] = 'rank',
+            year: Optional[str] = None,
+            page: Optional[int] = 1,
+            count: Optional[int] = 30,
+            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    探索Bangumi
+    """
+    medias = BangumiChain().discover(type=type, cat=cat, sort=sort, year=year,
+                                     limit=count, offset=(page - 1) * count)
+    if medias:
+        return [media.to_dict() for media in medias]
+    return []
+
+
+@router.get("/douban_movies", summary="探索豆瓣电影", response_model=List[schemas.MediaInfo])
+def douban_movies(sort: Optional[str] = "R",
+                  tags: Optional[str] = "",
+                  page: Optional[int] = 1,
+                  count: Optional[int] = 30,
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣电影信息
+    """
+    movies = DoubanChain().douban_discover(mtype=MediaType.MOVIE,
+                                           sort=sort, tags=tags, page=page, count=count)
+    return [media.to_dict() for media in movies] if movies else []
+
+
+@router.get("/douban_tvs", summary="探索豆瓣剧集", response_model=List[schemas.MediaInfo])
+def douban_tvs(sort: Optional[str] = "R",
+               tags: Optional[str] = "",
+               page: Optional[int] = 1,
+               count: Optional[int] = 30,
+               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣剧集信息
+    """
+    tvs = DoubanChain().douban_discover(mtype=MediaType.TV,
+                                        sort=sort, tags=tags, page=page, count=count)
+    return [media.to_dict() for media in tvs] if tvs else []
+
+
+@router.get("/tmdb_movies", summary="探索TMDB电影", response_model=List[schemas.MediaInfo])
+def tmdb_movies(sort_by: Optional[str] = "popularity.desc",
+                with_genres: Optional[str] = "",
+                with_original_language: Optional[str] = "",
+                with_keywords: Optional[str] = "",
+                with_watch_providers: Optional[str] = "",
+                vote_average: Optional[float] = 0.0,
+                vote_count: Optional[int] = 0,
+                release_date: Optional[str] = "",
+                page: Optional[int] = 1,
+                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览TMDB电影信息
+    """
+    movies = TmdbChain().tmdb_discover(mtype=MediaType.MOVIE,
+                                       sort_by=sort_by,
+                                       with_genres=with_genres,
+                                       with_original_language=with_original_language,
+                                       with_keywords=with_keywords,
+                                       with_watch_providers=with_watch_providers,
+                                       vote_average=vote_average,
+                                       vote_count=vote_count,
+                                       release_date=release_date,
+                                       page=page)
+    return [movie.to_dict() for movie in movies] if movies else []
+
+
+@router.get("/tmdb_tvs", summary="探索TMDB剧集", response_model=List[schemas.MediaInfo])
+def tmdb_tvs(sort_by: Optional[str] = "popularity.desc",
+             with_genres: Optional[str] = "",
+             with_original_language: Optional[str] = "",
+             with_keywords: Optional[str] = "",
+             with_watch_providers: Optional[str] = "",
+             vote_average: Optional[float] = 0.0,
+             vote_count: Optional[int] = 0,
+             release_date: Optional[str] = "",
+             page: Optional[int] = 1,
+             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览TMDB剧集信息
+    """
+    tvs = TmdbChain().tmdb_discover(mtype=MediaType.TV,
+                                    sort_by=sort_by,
+                                    with_genres=with_genres,
+                                    with_original_language=with_original_language,
+                                    with_keywords=with_keywords,
+                                    with_watch_providers=with_watch_providers,
+                                    vote_average=vote_average,
+                                    vote_count=vote_count,
+                                    release_date=release_date,
+                                    page=page)
+    return [tv.to_dict() for tv in tvs] if tvs else []

app/api/endpoints/douban.py

@@ -1,152 +1,79 @@
-from typing import List, Any
+from typing import Any, List, Optional
 
-from fastapi import APIRouter, Depends, Response
-from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends
 
 from app import schemas
 from app.chain.douban import DoubanChain
-from app.core.config import settings
 from app.core.context import MediaInfo
 from app.core.security import verify_token
-from app.db import get_db
 from app.schemas import MediaType
-from app.utils.http import RequestUtils
 
 router = APIRouter()
 
 
-@router.get("/img/{imgurl:path}", summary="豆瓣图片代理")
-def douban_img(imgurl: str) -> Any:
-    """
-    豆瓣图片代理
-    """
-    if not imgurl:
-        return None
-    response = RequestUtils(headers={
-        'Referer': "https://movie.douban.com/"
-    }, ua=settings.USER_AGENT).get_res(url=imgurl)
-    if response:
-        return Response(content=response.content, media_type="image/jpeg")
-    return None
-
-
-@router.get("/recognize/{doubanid}", summary="豆瓣ID识别", response_model=schemas.Context)
-def recognize_doubanid(doubanid: str,
-                       db: Session = Depends(get_db),
-                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    根据豆瓣ID识别媒体信息
-    """
-    # 识别媒体信息
-    context = DoubanChain(db).recognize_by_doubanid(doubanid=doubanid)
-    if context:
-        return context.to_dict()
-    else:
-        return schemas.Context()
-
-
-@router.get("/showing", summary="豆瓣正在热映", response_model=List[schemas.MediaInfo])
-def movie_showing(page: int = 1,
-                  count: int = 30,
-                  db: Session = Depends(get_db),
+@router.get("/person/{person_id}", summary="人物详情", response_model=schemas.MediaPerson)
+def douban_person(person_id: int,
                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    浏览豆瓣正在热映
+    根据人物ID查询人物详情
     """
-    movies = DoubanChain(db).movie_showing(page=page, count=count)
-    if not movies:
-        return []
-    medias = [MediaInfo(douban_info=movie) for movie in movies]
-    return [media.to_dict() for media in medias]
+    return DoubanChain().person_detail(person_id=person_id)
 
 
-@router.get("/movies", summary="豆瓣电影", response_model=List[schemas.MediaInfo])
-def douban_movies(sort: str = "R",
-                  tags: str = "",
-                  page: int = 1,
-                  count: int = 30,
-                  db: Session = Depends(get_db),
-                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get("/person/credits/{person_id}", summary="人物参演作品", response_model=List[schemas.MediaInfo])
+def douban_person_credits(person_id: int,
+                          page: Optional[int] = 1,
+                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    浏览豆瓣电影信息
+    根据人物ID查询人物参演作品
     """
-    movies = DoubanChain(db).douban_discover(mtype=MediaType.MOVIE,
-                                             sort=sort, tags=tags, page=page, count=count)
-    if not movies:
-        return []
-    medias = [MediaInfo(douban_info=movie) for movie in movies]
-    return [media.to_dict() for media in medias
-            if media.poster_path
-            and "movie_large.jpg" not in media.poster_path
-            and "tv_normal.png" not in media.poster_path]
+    medias = DoubanChain().person_credits(person_id=person_id, page=page)
+    if medias:
+        return [media.to_dict() for media in medias]
+    return []
 
 
-@router.get("/tvs", summary="豆瓣剧集", response_model=List[schemas.MediaInfo])
-def douban_tvs(sort: str = "R",
-               tags: str = "",
-               page: int = 1,
-               count: int = 30,
-               db: Session = Depends(get_db),
-               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get("/credits/{doubanid}/{type_name}", summary="豆瓣演员阵容", response_model=List[schemas.MediaPerson])
+def douban_credits(doubanid: str,
+                   type_name: str,
+                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    浏览豆瓣剧集信息
+    根据豆瓣ID查询演员阵容，type_name: 电影/电视剧
     """
-    tvs = DoubanChain(db).douban_discover(mtype=MediaType.TV,
-                                          sort=sort, tags=tags, page=page, count=count)
-    if not tvs:
-        return []
-    medias = [MediaInfo(douban_info=tv) for tv in tvs]
-    return [media.to_dict() for media in medias
-            if media.poster_path
-            and "movie_large.jpg" not in media.poster_path
-            and "tv_normal.jpg" not in media.poster_path
-            and "tv_large.jpg" not in media.poster_path]
+    mediatype = MediaType(type_name)
+    if mediatype == MediaType.MOVIE:
+        return DoubanChain().movie_credits(doubanid=doubanid)
+    elif mediatype == MediaType.TV:
+        return DoubanChain().tv_credits(doubanid=doubanid)
+    return []
 
 
-@router.get("/movie_top250", summary="豆瓣电影TOP250", response_model=List[schemas.MediaInfo])
-def movie_top250(page: int = 1,
-                 count: int = 30,
-                 db: Session = Depends(get_db),
-                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览豆瓣剧集信息
-    """
-    movies = DoubanChain(db).movie_top250(page=page, count=count)
-    return [MediaInfo(douban_info=movie).to_dict() for movie in movies]
-
-
-@router.get("/tv_weekly_chinese", summary="豆瓣国产剧集周榜", response_model=List[schemas.MediaInfo])
-def tv_weekly_chinese(page: int = 1,
-                      count: int = 30,
-                      db: Session = Depends(get_db),
-                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    中国每周剧集口碑榜
-    """
-    tvs = DoubanChain(db).tv_weekly_chinese(page=page, count=count)
-    return [MediaInfo(douban_info=tv).to_dict() for tv in tvs]
-
-
-@router.get("/tv_weekly_global", summary="豆瓣全球剧集周榜", response_model=List[schemas.MediaInfo])
-def tv_weekly_global(page: int = 1,
-                     count: int = 30,
-                     db: Session = Depends(get_db),
+@router.get("/recommend/{doubanid}/{type_name}", summary="豆瓣推荐电影/电视剧", response_model=List[schemas.MediaInfo])
+def douban_recommend(doubanid: str,
+                     type_name: str,
                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    全球每周剧集口碑榜
+    根据豆瓣ID查询推荐电影/电视剧，type_name: 电影/电视剧
     """
-    tvs = DoubanChain(db).tv_weekly_global(page=page, count=count)
-    return [MediaInfo(douban_info=tv).to_dict() for tv in tvs]
+    mediatype = MediaType(type_name)
+    if mediatype == MediaType.MOVIE:
+        medias = DoubanChain().movie_recommend(doubanid=doubanid)
+    elif mediatype == MediaType.TV:
+        medias = DoubanChain().tv_recommend(doubanid=doubanid)
+    else:
+        return []
+    if medias:
+        return [media.to_dict() for media in medias]
+    return []
 
 
 @router.get("/{doubanid}", summary="查询豆瓣详情", response_model=schemas.MediaInfo)
 def douban_info(doubanid: str,
-                db: Session = Depends(get_db),
                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据豆瓣ID查询豆瓣媒体信息
     """
-    doubaninfo = DoubanChain(db).douban_info(doubanid=doubanid)
+    doubaninfo = DoubanChain().douban_info(doubanid=doubanid)
     if doubaninfo:
         return MediaInfo(douban_info=doubaninfo).to_dict()
     else:

app/api/endpoints/download.py

@@ -1,39 +1,40 @@
-from typing import Any, List
+from typing import Any, List, Annotated, Optional
 
-from fastapi import APIRouter, Depends, HTTPException
-from sqlalchemy.orm import Session
+from fastapi import APIRouter, Depends, Body
 
 from app import schemas
-from app.chain.douban import DoubanChain
 from app.chain.download import DownloadChain
 from app.chain.media import MediaChain
 from app.core.context import MediaInfo, Context, TorrentInfo
 from app.core.metainfo import MetaInfo
 from app.core.security import verify_token
-from app.db import get_db
-from app.schemas import NotExistMediaInfo, MediaType
+from app.db.models.user import User
+from app.db.systemconfig_oper import SystemConfigOper
+from app.db.user_oper import get_current_active_user
+from app.schemas.types import SystemConfigKey
 
 router = APIRouter()
 
 
 @router.get("/", summary="正在下载", response_model=List[schemas.DownloadingTorrent])
-def read_downloading(
-        db: Session = Depends(get_db),
+def current(
+        name: Optional[str] = None,
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询正在下载的任务
     """
-    return DownloadChain(db).downloading()
+    return DownloadChain().downloading(name)
 
 
-@router.post("/", summary="添加下载", response_model=schemas.Response)
-def add_downloading(
+@router.post("/", summary="添加下载（含媒体信息）", response_model=schemas.Response)
+def download(
         media_in: schemas.MediaInfo,
         torrent_in: schemas.TorrentInfo,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+        downloader: Annotated[str | None, Body()] = None,
+        save_path: Annotated[str | None, Body()] = None,
+        current_user: User = Depends(get_current_active_user)) -> Any:
     """
-    添加下载任务
+    添加下载任务（含媒体信息）
     """
     # 元数据
     metainfo = MetaInfo(title=torrent_in.title, subtitle=torrent_in.description)
@@ -49,78 +50,85 @@ def add_downloading(
         media_info=mediainfo,
         torrent_info=torrentinfo
     )
-    did = DownloadChain(db).download_single(context=context)
-    return schemas.Response(success=True if did else False, data={
+    did = DownloadChain().download_single(context=context, username=current_user.name,
+                                          downloader=downloader, save_path=save_path, source="Manual")
+    if not did:
+        return schemas.Response(success=False, message="任务添加失败")
+    return schemas.Response(success=True, data={
         "download_id": did
     })
 
 
-@router.post("/notexists", summary="查询缺失媒体信息", response_model=List[NotExistMediaInfo])
-def exists(media_in: schemas.MediaInfo,
-           db: Session = Depends(get_db),
-           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.post("/add", summary="添加下载（不含媒体信息）", response_model=schemas.Response)
+def add(
+        torrent_in: schemas.TorrentInfo,
+        downloader: Annotated[str | None, Body()] = None,
+        save_path: Annotated[str | None, Body()] = None,
+        current_user: User = Depends(get_current_active_user)) -> Any:
     """
-    查询缺失媒体信息
+    添加下载任务（不含媒体信息）
     """
+    # 元数据
+    metainfo = MetaInfo(title=torrent_in.title, subtitle=torrent_in.description)
     # 媒体信息
-    mediainfo = MediaInfo()
-    meta = MetaInfo(title=media_in.title)
-    if media_in.tmdb_id:
-        mediainfo.from_dict(media_in.dict())
-    elif media_in.douban_id:
-        context = DoubanChain(db).recognize_by_doubanid(doubanid=media_in.douban_id)
-        if context:
-            mediainfo = context.media_info
-            meta = context.meta_info
-    else:
-        context = MediaChain(db).recognize_by_title(title=f"{media_in.title} {media_in.year}")
-        if context:
-            mediainfo = context.media_info
-            meta = context.meta_info
-    # 查询缺失信息
-    if not mediainfo or not mediainfo.tmdb_id:
-        raise HTTPException(status_code=404, detail="媒体信息不存在")
-    exist_flag, no_exists = DownloadChain(db).get_no_exists_info(meta=meta, mediainfo=mediainfo)
-    if mediainfo.type == MediaType.MOVIE:
-        # 电影已存在时返回空列表，存在时返回空对像列表
-        return [] if exist_flag else [NotExistMediaInfo()]
-    elif no_exists and no_exists.get(mediainfo.tmdb_id):
-        # 电视剧返回缺失的剧集
-        return list(no_exists.get(mediainfo.tmdb_id).values())
-    return []
+    mediainfo = MediaChain().recognize_media(meta=metainfo)
+    if not mediainfo:
+        return schemas.Response(success=False, message="无法识别媒体信息")
+    # 种子信息
+    torrentinfo = TorrentInfo()
+    torrentinfo.from_dict(torrent_in.dict())
+    # 上下文
+    context = Context(
+        meta_info=metainfo,
+        media_info=mediainfo,
+        torrent_info=torrentinfo
+    )
+    did = DownloadChain().download_single(context=context, username=current_user.name,
+                                          downloader=downloader, save_path=save_path, source="Manual")
+    if not did:
+        return schemas.Response(success=False, message="任务添加失败")
+    return schemas.Response(success=True, data={
+        "download_id": did
+    })
 
 
 @router.get("/start/{hashString}", summary="开始任务", response_model=schemas.Response)
-def start_downloading(
-        hashString: str,
-        db: Session = Depends(get_db),
+def start(
+        hashString: str, name: Optional[str] = None,
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     开如下载任务
     """
-    ret = DownloadChain(db).set_downloading(hashString, "start")
+    ret = DownloadChain().set_downloading(hashString, "start", name=name)
     return schemas.Response(success=True if ret else False)
 
 
 @router.get("/stop/{hashString}", summary="暂停任务", response_model=schemas.Response)
-def stop_downloading(
-        hashString: str,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def stop(hashString: str, name: Optional[str] = None,
+         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    控制下载任务
+    暂停下载任务
     """
-    ret = DownloadChain(db).set_downloading(hashString, "stop")
+    ret = DownloadChain().set_downloading(hashString, "stop", name=name)
     return schemas.Response(success=True if ret else False)
 
 
+@router.get("/clients", summary="查询可用下载器", response_model=List[dict])
+def clients(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询可用下载器
+    """
+    downloaders: List[dict] = SystemConfigOper().get(SystemConfigKey.Downloaders)
+    if downloaders:
+        return [{"name": d.get("name"), "type": d.get("type")} for d in downloaders if d.get("enabled")]
+    return []
+
+
 @router.delete("/{hashString}", summary="删除下载任务", response_model=schemas.Response)
-def remove_downloading(
-        hashString: str,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def delete(hashString: str, name: Optional[str] = None,
+           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    控制下载任务
+    删除下载任务
     """
-    ret = DownloadChain(db).remove_downloading(hashString)
+    ret = DownloadChain().remove_downloading(hashString, name=name)
     return schemas.Response(success=True if ret else False)

app/api/endpoints/filebrowser.py

@@ -1,189 +0,0 @@
-import shutil
-from pathlib import Path
-from typing import Any, List
-
-from fastapi import APIRouter, Depends
-from starlette.responses import FileResponse, Response
-
-from app import schemas
-from app.core.config import settings
-from app.core.security import verify_token
-from app.log import logger
-from app.utils.system import SystemUtils
-
-router = APIRouter()
-
-IMAGE_TYPES = [".jpg", ".png", ".gif", ".bmp", ".jpeg", ".webp"]
-
-
-@router.get("/list", summary="所有目录和文件", response_model=List[schemas.FileItem])
-def list_path(path: str,
-              sort: str = 'time',
-              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    查询当前目录下所有目录和文件
-    :param path: 目录路径
-    :param sort: 排序方式，name:按名称排序，time:按修改时间排序
-    :param _: token
-    :return: 所有目录和文件
-    """
-    # 返回结果
-    ret_items = []
-    if not path or path == "/":
-        if SystemUtils.is_windows():
-            partitions = SystemUtils.get_windows_drives() or ["C:/"]
-            for partition in partitions:
-                ret_items.append(schemas.FileItem(
-                    type="dir",
-                    path=partition + "/",
-                    name=partition,
-                    basename=partition
-                ))
-            return ret_items
-        else:
-            path = "/"
-    else:
-        if not SystemUtils.is_windows() and not path.startswith("/"):
-            path = "/" + path
-
-    # 遍历目录
-    path_obj = Path(path)
-    if not path_obj.exists():
-        logger.error(f"目录不存在：{path}")
-        return []
-
-    # 如果是文件
-    if path_obj.is_file():
-        ret_items.append(schemas.FileItem(
-            type="file",
-            path=str(path_obj).replace("\\", "/"),
-            name=path_obj.name,
-            basename=path_obj.stem,
-            extension=path_obj.suffix[1:],
-            size=path_obj.stat().st_size,
-            modify_time=path_obj.stat().st_mtime,
-        ))
-        return ret_items
-
-    # 扁历所有目录
-    for item in SystemUtils.list_sub_directory(path_obj):
-        ret_items.append(schemas.FileItem(
-            type="dir",
-            path=str(item).replace("\\", "/") + "/",
-            name=item.name,
-            basename=item.stem,
-            modify_time=item.stat().st_mtime,
-        ))
-
-    # 遍历所有文件，不含子目录
-    for item in SystemUtils.list_sub_files(path_obj,
-                                           settings.RMT_MEDIAEXT
-                                           + settings.RMT_SUBEXT
-                                           + IMAGE_TYPES
-                                           + [".nfo"]):
-        ret_items.append(schemas.FileItem(
-            type="file",
-            path=str(item).replace("\\", "/"),
-            name=item.name,
-            basename=item.stem,
-            extension=item.suffix[1:],
-            size=item.stat().st_size,
-            modify_time=item.stat().st_mtime,
-        ))
-    # 排序
-    if sort == 'time':
-        ret_items.sort(key=lambda x: x.modify_time, reverse=True)
-    else:
-        ret_items.sort(key=lambda x: x.name, reverse=False)
-    return ret_items
-
-
-@router.get("/mkdir", summary="创建目录", response_model=schemas.Response)
-def mkdir(path: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    创建目录
-    """
-    if not path:
-        return schemas.Response(success=False)
-    path_obj = Path(path)
-    if path_obj.exists():
-        return schemas.Response(success=False)
-    path_obj.mkdir(parents=True, exist_ok=True)
-    return schemas.Response(success=True)
-
-
-@router.get("/delete", summary="删除文件或目录", response_model=schemas.Response)
-def delete(path: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    删除文件或目录
-    """
-    if not path:
-        return schemas.Response(success=False)
-    path_obj = Path(path)
-    if not path_obj.exists():
-        return schemas.Response(success=True)
-    if path_obj.is_file():
-        path_obj.unlink()
-    else:
-        shutil.rmtree(path_obj, ignore_errors=True)
-    return schemas.Response(success=True)
-
-
-@router.get("/download", summary="下载文件或目录")
-def download(path: str, token: str) -> Any:
-    """
-    下载文件或目录
-    """
-    if not path:
-        return schemas.Response(success=False)
-    # 认证token
-    if not verify_token(token):
-        return None
-    path_obj = Path(path)
-    if not path_obj.exists():
-        return schemas.Response(success=False)
-    if path_obj.is_file():
-        # 做为文件流式下载
-        return FileResponse(path_obj)
-    else:
-        # 做为压缩包下载
-        shutil.make_archive(base_name=path_obj.stem, format="zip", root_dir=path_obj)
-        reponse = Response(content=path_obj.read_bytes(), media_type="application/zip")
-        # 删除压缩包
-        Path(f"{path_obj.stem}.zip").unlink()
-        return reponse
-
-
-@router.get("/rename", summary="重命名文件或目录", response_model=schemas.Response)
-def rename(path: str, new_name: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    重命名文件或目录
-    """
-    if not path or not new_name:
-        return schemas.Response(success=False)
-    path_obj = Path(path)
-    if not path_obj.exists():
-        return schemas.Response(success=False)
-    path_obj.rename(path_obj.parent / new_name)
-    return schemas.Response(success=True)
-
-
-@router.get("/image", summary="读取图片")
-def image(path: str, token: str) -> Any:
-    """
-    读取图片
-    """
-    if not path:
-        return None
-    # 认证token
-    if not verify_token(token):
-        return None
-    path_obj = Path(path)
-    if not path_obj.exists():
-        return None
-    if not path_obj.is_file():
-        return None
-    # 判断是否图片文件
-    if path_obj.suffix.lower() not in IMAGE_TYPES:
-        return None
-    return Response(content=path_obj.read_bytes(), media_type="image/jpeg")

app/api/endpoints/history.py

@@ -1,25 +1,26 @@
-from pathlib import Path
-from typing import List, Any
+from typing import List, Any, Optional
 
+import jieba
 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 
 from app import schemas
-from app.chain.transfer import TransferChain
+from app.chain.storage import StorageChain
 from app.core.event import eventmanager
 from app.core.security import verify_token
 from app.db import get_db
+from app.db.models import User
 from app.db.models.downloadhistory import DownloadHistory
 from app.db.models.transferhistory import TransferHistory
-from app.schemas import MediaType
-from app.schemas.types import EventType
+from app.db.user_oper import get_current_active_superuser
+from app.schemas.types import EventType, MediaType
 
 router = APIRouter()
 
 
 @router.get("/download", summary="查询下载历史记录", response_model=List[schemas.DownloadHistory])
-def download_history(page: int = 1,
-                     count: int = 30,
+def download_history(page: Optional[int] = 1,
+                     count: Optional[int] = 30,
                      db: Session = Depends(get_db),
                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
@@ -39,21 +40,32 @@ def delete_download_history(history_in: schemas.DownloadHistory,
     return schemas.Response(success=True)
 
 
-@router.get("/transfer", summary="查询转移历史记录", response_model=schemas.Response)
-def transfer_history(title: str = None,
-                     page: int = 1,
-                     count: int = 30,
+@router.get("/transfer", summary="查询整理记录", response_model=schemas.Response)
+def transfer_history(title: Optional[str] = None,
+                     page: Optional[int] = 1,
+                     count: Optional[int] = 30,
+                     status: Optional[bool] = None,
                      db: Session = Depends(get_db),
                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    查询转移历史记录
+    查询整理记录
     """
+    if title == "失败":
+        title = None
+        status = False
+    elif title == "成功":
+        title = None
+        status = True
+
     if title:
-        total = TransferHistory.count_by_title(db, title)
-        result = TransferHistory.list_by_title(db, title, page, count)
+        words = jieba.cut(title, HMM=False)
+        title = "%".join(words)
+        total = TransferHistory.count_by_title(db, title=title, status=status)
+        result = TransferHistory.list_by_title(db, title=title, page=page,
+                                               count=count, status=status)
     else:
-        result = TransferHistory.list_by_page(db, page, count)
-        total = TransferHistory.count(db)
+        result = TransferHistory.list_by_page(db, page=page, count=count, status=status)
+        total = TransferHistory.count(db, status=status)
 
     return schemas.Response(success=True,
                             data={
@@ -62,29 +74,35 @@ def transfer_history(title: str = None,
                             })
 
 
-@router.delete("/transfer", summary="删除转移历史记录", response_model=schemas.Response)
+@router.delete("/transfer", summary="删除整理记录", response_model=schemas.Response)
 def delete_transfer_history(history_in: schemas.TransferHistory,
-                            deletesrc: bool = False,
-                            deletedest: bool = False,
+                            deletesrc: Optional[bool] = False,
+                            deletedest: Optional[bool] = False,
                             db: Session = Depends(get_db),
-                            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+                            _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
     """
-    删除转移历史记录
+    删除整理记录
     """
-    history = TransferHistory.get(db, history_in.id)
+    history: TransferHistory = TransferHistory.get(db, history_in.id)
     if not history:
-        return schemas.Response(success=False, msg="记录不存在")
+        return schemas.Response(success=False, message="记录不存在")
     # 册除媒体库文件
-    if deletedest and history.dest:
-        TransferChain(db).delete_files(Path(history.dest))
+    if deletedest and history.dest_fileitem:
+        dest_fileitem = schemas.FileItem(**history.dest_fileitem)
+        StorageChain().delete_media_file(fileitem=dest_fileitem, mtype=MediaType(history.type))
+
     # 删除源文件
-    if deletesrc and history.src:
-        TransferChain(db).delete_files(Path(history.src))
+    if deletesrc and history.src_fileitem:
+        src_fileitem = schemas.FileItem(**history.src_fileitem)
+        state = StorageChain().delete_media_file(src_fileitem)
+        if not state:
+            return schemas.Response(success=False, message=f"{src_fileitem.path} 删除失败")
         # 发送事件
         eventmanager.send_event(
             EventType.DownloadFileDeleted,
             {
-                "src": history.src
+                "src": history.src,
+                "hash": history.download_hash
             }
         )
     # 删除记录
@@ -92,21 +110,11 @@ def delete_transfer_history(history_in: schemas.TransferHistory,
     return schemas.Response(success=True)
 
 
-@router.post("/transfer", summary="历史记录重新转移", response_model=schemas.Response)
-def redo_transfer_history(history_in: schemas.TransferHistory,
-                          mtype: str = None,
-                          new_tmdbid: int = None,
-                          db: Session = Depends(get_db),
-                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get("/empty/transfer", summary="清空整理记录", response_model=schemas.Response)
+def delete_transfer_history(db: Session = Depends(get_db),
+                            _: User = Depends(get_current_active_superuser)) -> Any:
     """
-    历史记录重新转移，不输入 mtype 和 new_tmdbid 时，自动使用文件名重新识别
+    清空整理记录
     """
-    if mtype and new_tmdbid:
-        state, errmsg = TransferChain(db).re_transfer(logid=history_in.id,
-                                                      mtype=MediaType(mtype), tmdbid=new_tmdbid)
-    else:
-        state, errmsg = TransferChain(db).re_transfer(logid=history_in.id)
-    if state:
-        return schemas.Response(success=True)
-    else:
-        return schemas.Response(success=False, message=errmsg)
+    TransferHistory.truncate(db)
+    return schemas.Response(success=True)

app/api/endpoints/login.py

@@ -1,87 +1,70 @@
 from datetime import timedelta
-from typing import Any
+from typing import Any, List, Annotated
 
-from fastapi import APIRouter, Depends, HTTPException
+from fastapi import APIRouter, Depends, Form, HTTPException
 from fastapi.security import OAuth2PasswordRequestForm
-from sqlalchemy.orm import Session
 
 from app import schemas
-from app.chain.tmdb import TmdbChain
 from app.chain.user import UserChain
 from app.core import security
 from app.core.config import settings
-from app.core.security import get_password_hash
-from app.db import get_db
-from app.db.models.user import User
-from app.log import logger
-from app.utils.web import WebUtils
+from app.helper.sites import SitesHelper
+from app.helper.wallpaper import WallpaperHelper
 
 router = APIRouter()
 
 
 @router.post("/access-token", summary="获取token", response_model=schemas.Token)
-async def login_access_token(
-        db: Session = Depends(get_db), form_data: OAuth2PasswordRequestForm = Depends()
+def login_access_token(
+        form_data: Annotated[OAuth2PasswordRequestForm, Depends()],
+        otp_password: Annotated[str | None, Form()] = None
 ) -> Any:
     """
     获取认证Token
     """
-    # 检查数据库
-    user = User.authenticate(
-        db=db,
-        name=form_data.username,
-        password=form_data.password
-    )
-    if not user:
-        # 请求协助认证
-        logger.warn("登录用户本地不匹配，尝试辅助认证 ...")
-        token = UserChain(db).user_authenticate(form_data.username, form_data.password)
-        if not token:
-            raise HTTPException(status_code=401, detail="用户名或密码不正确")
-        else:
-            logger.info(f"辅助认证成功，用户信息: {token}")
-            # 加入用户信息表
-            user = User.get_by_name(db=db, name=form_data.username)
-            if not user:
-                logger.info(f"用户不存在，创建用户: {form_data.username}")
-                user = User(name=form_data.username, is_active=True,
-                            is_superuser=False, hashed_password=get_password_hash(token))
-                user.create(db)
-    elif not user.is_active:
-        raise HTTPException(status_code=403, detail="用户未启用")
-    access_token_expires = timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES)
+    success, user_or_message = UserChain().user_authenticate(username=form_data.username,
+                                                             password=form_data.password,
+                                                             mfa_code=otp_password)
+
+    if not success:
+        raise HTTPException(status_code=401, detail=user_or_message)
+
+    level = SitesHelper().auth_level
     return schemas.Token(
         access_token=security.create_access_token(
-            user.id, expires_delta=access_token_expires
+            userid=user_or_message.id,
+            username=user_or_message.name,
+            super_user=user_or_message.is_superuser,
+            expires_delta=timedelta(minutes=settings.ACCESS_TOKEN_EXPIRE_MINUTES),
+            level=level
         ),
         token_type="bearer",
-        super_user=user.is_superuser,
-        user_name=user.name,
-        avatar=user.avatar
+        super_user=user_or_message.is_superuser,
+        user_id=user_or_message.id,
+        user_name=user_or_message.name,
+        avatar=user_or_message.avatar,
+        level=level,
+        permissions= user_or_message.permissions or {},
     )
 
 
-@router.get("/bing", summary="Bing每日壁纸", response_model=schemas.Response)
-def bing_wallpaper() -> Any:
+@router.get("/wallpaper", summary="登录页面电影海报", response_model=schemas.Response)
+def wallpaper() -> Any:
     """
-    获取Bing每日壁纸
+    获取登录页面电影海报
     """
-    url = WebUtils.get_bing_wallpaper()
+    url = WallpaperHelper().get_wallpaper()
     if url:
-        return schemas.Response(success=False,
-                                message=url)
-    return schemas.Response(success=False)
-
-
-@router.get("/tmdb", summary="TMDB电影海报", response_model=schemas.Response)
-def tmdb_wallpaper(db: Session = Depends(get_db)) -> Any:
-    """
-    获取TMDB电影海报
-    """
-    wallpager = TmdbChain(db).get_random_wallpager()
-    if wallpager:
         return schemas.Response(
             success=True,
-            message=wallpager
+            message=url
         )
     return schemas.Response(success=False)
+
+
+@router.get("/wallpapers", summary="登录页面电影海报列表", response_model=List[str])
+def wallpapers() -> Any:
+    """
+    获取登录页面电影海报
+    """
+    return WallpaperHelper().get_wallpapers()

app/api/endpoints/media.py

@@ -1,110 +1,243 @@
-from typing import List, Any
+from pathlib import Path
+from typing import List, Any, Union, Annotated, Optional
 
 from fastapi import APIRouter, Depends
-from sqlalchemy.orm import Session
 
 from app import schemas
-from app.chain.douban import DoubanChain
 from app.chain.media import MediaChain
 from app.chain.tmdb import TmdbChain
-from app.core.context import MediaInfo
-from app.core.metainfo import MetaInfo
-from app.core.security import verify_token
-from app.db import get_db
-from app.db.mediaserver_oper import MediaServerOper
-from app.schemas import MediaType
+from app.core.config import settings
+from app.core.context import Context
+from app.core.event import eventmanager
+from app.core.metainfo import MetaInfo, MetaInfoPath
+from app.core.security import verify_token, verify_apitoken
+from app.schemas import MediaType, MediaRecognizeConvertEventData
+from app.schemas.types import ChainEventType
 
 router = APIRouter()
 
 
 @router.get("/recognize", summary="识别媒体信息（种子）", response_model=schemas.Context)
 def recognize(title: str,
-              subtitle: str = None,
-              db: Session = Depends(get_db),
+              subtitle: Optional[str] = None,
               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据标题、副标题识别媒体信息
     """
     # 识别媒体信息
-    context = MediaChain(db).recognize_by_title(title=title, subtitle=subtitle)
-    if context:
-        return context.to_dict()
+    metainfo = MetaInfo(title, subtitle)
+    mediainfo = MediaChain().recognize_by_meta(metainfo)
+    if mediainfo:
+        return Context(meta_info=metainfo, media_info=mediainfo).to_dict()
     return schemas.Context()
 
 
+@router.get("/recognize2", summary="识别种子媒体信息（API_TOKEN）", response_model=schemas.Context)
+def recognize2(_: Annotated[str, Depends(verify_apitoken)],
+               title: str,
+               subtitle: Optional[str] = None
+               ) -> Any:
+    """
+    根据标题、副标题识别媒体信息 API_TOKEN认证（?token=xxx）
+    """
+    # 识别媒体信息
+    return recognize(title, subtitle)
+
+
 @router.get("/recognize_file", summary="识别媒体信息（文件）", response_model=schemas.Context)
-def recognize(path: str,
-              db: Session = Depends(get_db),
-              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def recognize_file(path: str,
+                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据文件路径识别媒体信息
     """
     # 识别媒体信息
-    context = MediaChain(db).recognize_by_path(path)
+    context = MediaChain().recognize_by_path(path)
     if context:
         return context.to_dict()
     return schemas.Context()
 
 
-@router.get("/search", summary="搜索媒体信息", response_model=List[schemas.MediaInfo])
-def search_by_title(title: str,
-                    page: int = 1,
-                    count: int = 8,
-                    db: Session = Depends(get_db),
-                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get("/recognize_file2", summary="识别文件媒体信息（API_TOKEN）", response_model=schemas.Context)
+def recognize_file2(path: str,
+                    _: Annotated[str, Depends(verify_apitoken)]) -> Any:
     """
-    模糊搜索媒体信息列表
+    根据文件路径识别媒体信息 API_TOKEN认证（?token=xxx）
     """
-    _, medias = MediaChain(db).search(title=title)
-    if medias:
-        return [media.to_dict() for media in medias[(page - 1) * count: page * count]]
+    # 识别媒体信息
+    return recognize_file(path)
+
+
+@router.get("/search", summary="搜索媒体/人物信息", response_model=List[dict])
+def search(title: str,
+           type: Optional[str] = "media",
+           page: int = 1,
+           count: int = 8,
+           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    模糊搜索媒体/人物信息列表 media：媒体信息，person：人物信息
+    """
+
+    def __get_source(obj: Union[schemas.MediaInfo, schemas.MediaPerson, dict]):
+        """
+        获取对象属性
+        """
+        if isinstance(obj, dict):
+            return obj.get("source")
+        return obj.source
+
+    result = []
+    if type == "media":
+        _, medias = MediaChain().search(title=title)
+        if medias:
+            result = [media.to_dict() for media in medias]
+    elif type == "collection":
+        result = MediaChain().search_collections(name=title)
+    else:
+        result = MediaChain().search_persons(name=title)
+    if result:
+        # 按设置的顺序对结果进行排序
+        setting_order = settings.SEARCH_SOURCE.split(',') or []
+        sort_order = {}
+        for index, source in enumerate(setting_order):
+            sort_order[source] = index
+        result = sorted(result, key=lambda x: sort_order.get(__get_source(x), 4))
+    return result[(page - 1) * count:page * count]
+
+
+@router.post("/scrape/{storage}", summary="刮削媒体信息", response_model=schemas.Response)
+def scrape(fileitem: schemas.FileItem,
+           storage: Optional[str] = "local",
+           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    刮削媒体信息
+    """
+    if not fileitem or not fileitem.path:
+        return schemas.Response(success=False, message="刮削路径无效")
+    chain = MediaChain()
+    # 识别媒体信息
+    scrape_path = Path(fileitem.path)
+    meta = MetaInfoPath(scrape_path)
+    mediainfo = chain.recognize_by_meta(meta)
+    if not mediainfo:
+        return schemas.Response(success=False, message="刮削失败，无法识别媒体信息")
+    if storage == "local":
+        if not scrape_path.exists():
+            return schemas.Response(success=False, message="刮削路径不存在")
+    # 手动刮削
+    chain.scrape_metadata(fileitem=fileitem, meta=meta, mediainfo=mediainfo, overwrite=True)
+    return schemas.Response(success=True, message=f"{fileitem.path} 刮削完成")
+
+
+@router.get("/category", summary="查询自动分类配置", response_model=dict)
+def category(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询自动分类配置
+    """
+    return MediaChain().media_category() or {}
+
+
+@router.get("/group/seasons/{episode_group}", summary="查询剧集组季信息", response_model=List[schemas.MediaSeason])
+def group_seasons(episode_group: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询剧集组季信息（themoviedb）
+    """
+    return TmdbChain().tmdb_group_seasons(group_id=episode_group)
+
+
+@router.get("/groups/{tmdbid}", summary="查询媒体剧集组", response_model=List[dict])
+def seasons(tmdbid: int, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询媒体剧集组列表（themoviedb）
+    """
+    mediainfo = MediaChain().recognize_media(tmdbid=tmdbid, mtype=MediaType.TV)
+    if not mediainfo:
+        return []
+    return mediainfo.episode_groups
+
+
+@router.get("/seasons", summary="查询媒体季信息", response_model=List[schemas.MediaSeason])
+def seasons(mediaid: Optional[str] = None,
+            title: Optional[str] = None,
+            year: str = None,
+            season: int = None,
+            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询媒体季信息
+    """
+    if mediaid:
+        if mediaid.startswith("tmdb:"):
+            tmdbid = int(mediaid[5:])
+            seasons_info = TmdbChain().tmdb_seasons(tmdbid=tmdbid)
+            if seasons_info:
+                if season:
+                    return [sea for sea in seasons_info if sea.season_number == season]
+                return seasons_info
+    if title:
+        meta = MetaInfo(title)
+        if year:
+            meta.year = year
+        mediainfo = MediaChain().recognize_media(meta, mtype=MediaType.TV)
+        if mediainfo:
+            if settings.RECOGNIZE_SOURCE == "themoviedb":
+                seasons_info = TmdbChain().tmdb_seasons(tmdbid=mediainfo.tmdb_id)
+                if seasons_info:
+                    if season:
+                        return [sea for sea in seasons_info if sea.season_number == season]
+                    return seasons_info
+            else:
+                sea = season or 1
+                return schemas.MediaSeason(
+                    season_number=sea,
+                    poster_path=mediainfo.poster_path,
+                    name=f"第 {sea} 季",
+                    air_date=mediainfo.release_date,
+                    overview=mediainfo.overview,
+                    vote_average=mediainfo.vote_average,
+                    episode_count=mediainfo.number_of_episodes
+                )
     return []
 
 
-@router.get("/exists", summary="本地是否存在", response_model=schemas.Response)
-def exists(title: str = None,
-           year: int = None,
-           mtype: str = None,
-           tmdbid: int = None,
-           season: int = None,
-           db: Session = Depends(get_db),
-           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    判断本地是否存在
-    """
-    meta = MetaInfo(title)
-    if not season:
-        season = meta.begin_season
-    exist = MediaServerOper(db).exists(
-        title=meta.name, year=year, mtype=mtype, tmdbid=tmdbid, season=season
-    )
-    return schemas.Response(success=True if exist else False, data={
-        "item": exist or {}
-    })
-
-
 @router.get("/{mediaid}", summary="查询媒体详情", response_model=schemas.MediaInfo)
-def tmdb_info(mediaid: str, type_name: str,
-              db: Session = Depends(get_db),
-              _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def detail(mediaid: str, type_name: str, title: Optional[str] = None, year: str = None,
+           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据媒体ID查询themoviedb或豆瓣媒体信息，type_name: 电影/电视剧
     """
     mtype = MediaType(type_name)
+    mediainfo = None
     if mediaid.startswith("tmdb:"):
-        result = TmdbChain(db).tmdb_info(int(mediaid[5:]), mtype)
-        return MediaInfo(tmdb_info=result).to_dict()
+        mediainfo = MediaChain().recognize_media(tmdbid=int(mediaid[5:]), mtype=mtype)
     elif mediaid.startswith("douban:"):
-        # 查询豆瓣信息
-        doubaninfo = DoubanChain(db).douban_info(doubanid=mediaid[7:])
-        if not doubaninfo:
-            return schemas.MediaInfo()
-        result = DoubanChain(db).recognize_by_doubaninfo(doubaninfo)
-        if result:
-            # TMDB
-            return result.media_info.to_dict()
-        else:
-            # 豆瓣
-            return MediaInfo(douban_info=doubaninfo).to_dict()
+        mediainfo = MediaChain().recognize_media(doubanid=mediaid[7:], mtype=mtype)
+    elif mediaid.startswith("bangumi:"):
+        mediainfo = MediaChain().recognize_media(bangumiid=int(mediaid[8:]), mtype=mtype)
     else:
-        return schemas.MediaInfo()
+        # 广播事件解析媒体信息
+        event_data = MediaRecognizeConvertEventData(
+            mediaid=mediaid,
+            convert_type=settings.RECOGNIZE_SOURCE
+        )
+        event = eventmanager.send_event(ChainEventType.MediaRecognizeConvert, event_data)
+        # 使用事件返回的上下文数据
+        if event and event.event_data and event.event_data.media_dict:
+            event_data: MediaRecognizeConvertEventData = event.event_data
+            new_id = event_data.media_dict.get("id")
+            if event_data.convert_type == "themoviedb":
+                mediainfo = MediaChain().recognize_media(tmdbid=new_id, mtype=mtype)
+            elif event_data.convert_type == "douban":
+                mediainfo = MediaChain().recognize_media(doubanid=new_id, mtype=mtype)
+        elif title:
+            # 使用名称识别兜底
+            meta = MetaInfo(title)
+            if year:
+                meta.year = year
+            if mtype:
+                meta.type = mtype
+            mediainfo = MediaChain().recognize_media(meta=meta)
+    # 识别
+    if mediainfo:
+        MediaChain().obtain_images(mediainfo)
+        return mediainfo.to_dict()
+
+    return schemas.MediaInfo()

app/api/endpoints/mediaserver.py

@@ -0,0 +1,158 @@
+from typing import Any, List, Dict, Optional
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from app import schemas
+from app.chain.download import DownloadChain
+from app.chain.mediaserver import MediaServerChain
+from app.core.context import MediaInfo
+from app.core.metainfo import MetaInfo
+from app.core.security import verify_token
+from app.db import get_db
+from app.db.mediaserver_oper import MediaServerOper
+from app.db.models import MediaServerItem
+from app.db.systemconfig_oper import SystemConfigOper
+from app.helper.mediaserver import MediaServerHelper
+from app.schemas import MediaType, NotExistMediaInfo
+from app.schemas.types import SystemConfigKey
+
+router = APIRouter()
+
+
+@router.get("/play/{itemid:path}", summary="在线播放")
+def play_item(itemid: str, _: schemas.TokenPayload = Depends(verify_token)) -> schemas.Response:
+    """
+    获取媒体服务器播放页面地址
+    """
+    if not itemid:
+        return schemas.Response(success=False, message="参数错误")
+    configs = MediaServerHelper().get_configs()
+    if not configs:
+        return schemas.Response(success=False, message="未配置媒体服务器")
+    media_chain = MediaServerChain()
+    for name in configs.keys():
+        item = media_chain.iteminfo(server=name, item_id=itemid)
+        if item:
+            play_url = media_chain.get_play_url(server=name, item_id=itemid)
+            if play_url:
+                return schemas.Response(success=True, data={
+                    "url": play_url
+                })
+    return schemas.Response(success=False, message="未找到播放地址")
+
+
+@router.get("/exists", summary="查询本地是否存在（数据库）", response_model=schemas.Response)
+def exists_local(title: Optional[str] = None,
+                 year: Optional[str] = None,
+                 mtype: Optional[str] = None,
+                 tmdbid: Optional[int] = None,
+                 season: Optional[int] = None,
+                 db: Session = Depends(get_db),
+                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    判断本地是否存在
+    """
+    meta = MetaInfo(title)
+    if not season:
+        season = meta.begin_season
+    # 返回对象
+    ret_info = {}
+    # 本地数据库是否存在
+    exist: MediaServerItem = MediaServerOper(db).exists(
+        title=meta.name, year=year, mtype=mtype, tmdbid=tmdbid, season=season
+    )
+    if exist:
+        ret_info = {
+            "id": exist.item_id
+        }
+    return schemas.Response(success=True if exist else False, data={
+        "item": ret_info
+    })
+
+
+@router.post("/exists_remote", summary="查询已存在的剧集信息（媒体服务器）", response_model=Dict[int, list])
+def exists(media_in: schemas.MediaInfo,
+           _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据媒体信息查询媒体库已存在的剧集信息
+    """
+    # 转化为媒体信息对象
+    mediainfo = MediaInfo()
+    mediainfo.from_dict(media_in.dict())
+    existsinfo: schemas.ExistMediaInfo = MediaServerChain().media_exists(mediainfo=mediainfo)
+    if not existsinfo:
+        return []
+    if media_in.season:
+        return {
+            media_in.season: existsinfo.seasons.get(media_in.season) or []
+        }
+    return existsinfo.seasons
+
+
+@router.post("/notexists", summary="查询媒体库缺失信息（媒体服务器）", response_model=List[schemas.NotExistMediaInfo])
+def not_exists(media_in: schemas.MediaInfo,
+               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据媒体信息查询缺失电影/剧集
+    """
+    # 媒体信息
+    meta = MetaInfo(title=media_in.title)
+    mtype = MediaType(media_in.type) if media_in.type else None
+    if mtype:
+        meta.type = mtype
+    if media_in.season:
+        meta.begin_season = media_in.season
+        meta.type = MediaType.TV
+    if media_in.year:
+        meta.year = media_in.year
+    # 转化为媒体信息对象
+    mediainfo = MediaInfo()
+    mediainfo.from_dict(media_in.dict())
+    exist_flag, no_exists = DownloadChain().get_no_exists_info(meta=meta, mediainfo=mediainfo)
+    mediakey = mediainfo.tmdb_id or mediainfo.douban_id
+    if mediainfo.type == MediaType.MOVIE:
+        # 电影已存在时返回空列表，不存在时返回空对像列表
+        return [] if exist_flag else [NotExistMediaInfo()]
+    elif no_exists and no_exists.get(mediakey):
+        # 电视剧返回缺失的剧集
+        return list(no_exists.get(mediakey).values())
+    return []
+
+
+@router.get("/latest", summary="最新入库条目", response_model=List[schemas.MediaServerPlayItem])
+def latest(server: str, count: Optional[int] = 20,
+           userinfo: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    获取媒体服务器最新入库条目
+    """
+    return MediaServerChain().latest(server=server, count=count, username=userinfo.username) or []
+
+
+@router.get("/playing", summary="正在播放条目", response_model=List[schemas.MediaServerPlayItem])
+def playing(server: str, count: Optional[int] = 12,
+            userinfo: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    获取媒体服务器正在播放条目
+    """
+    return MediaServerChain().playing(server=server, count=count, username=userinfo.username) or []
+
+
+@router.get("/library", summary="媒体库列表", response_model=List[schemas.MediaServerLibrary])
+def library(server: str, hidden: Optional[bool] = False,
+            userinfo: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    获取媒体服务器媒体库列表
+    """
+    return MediaServerChain().librarys(server=server, username=userinfo.username, hidden=hidden) or []
+
+
+@router.get("/clients", summary="查询可用媒体服务器", response_model=List[dict])
+def clients(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询可用媒体服务器
+    """
+    mediaservers: List[dict] = SystemConfigOper().get(SystemConfigKey.MediaServers)
+    if mediaservers:
+        return [{"name": d.get("name"), "type": d.get("type")} for d in mediaservers if d.get("enabled")]
+    return []

app/api/endpoints/message.py

@@ -1,97 +1,160 @@
-from typing import Union, Any, List
+import json
+from typing import Union, Any, List, Optional
 
-from fastapi import APIRouter, BackgroundTasks, Depends
-from fastapi import Request
+from fastapi import APIRouter, BackgroundTasks, Depends, Request
+from pywebpush import WebPushException, webpush
 from sqlalchemy.orm import Session
 from starlette.responses import PlainTextResponse
 
 from app import schemas
 from app.chain.message import MessageChain
-from app.core.config import settings
-from app.core.security import verify_token
+from app.core.config import settings, global_vars
+from app.core.security import verify_token, verify_apitoken
 from app.db import get_db
-from app.db.systemconfig_oper import SystemConfigOper
+from app.db.models import User
+from app.db.models.message import Message
+from app.db.user_oper import get_current_active_superuser
+from app.helper.service import ServiceConfigHelper
 from app.log import logger
 from app.modules.wechat.WXBizMsgCrypt3 import WXBizMsgCrypt
-from app.schemas import NotificationSwitch
-from app.schemas.types import SystemConfigKey, NotificationType
+from app.schemas.types import MessageChannel
 
 router = APIRouter()
 
 
-def start_message_chain(db: Session, body: Any, form: Any, args: Any):
+def start_message_chain(body: Any, form: Any, args: Any):
     """
     启动链式任务
     """
-    MessageChain(db).process(body=body, form=form, args=args)
+    MessageChain().process(body=body, form=form, args=args)
 
 
 @router.post("/", summary="接收用户消息", response_model=schemas.Response)
 async def user_message(background_tasks: BackgroundTasks, request: Request,
-                       db: Session = Depends(get_db)):
+                       _: schemas.TokenPayload = Depends(verify_apitoken)):
     """
-    用户消息响应
+    用户消息响应，配置请求中需要添加参数：token=API_TOKEN&source=消息配置名
     """
     body = await request.body()
     form = await request.form()
     args = request.query_params
-    background_tasks.add_task(start_message_chain, db, body, form, args)
+    background_tasks.add_task(start_message_chain, body, form, args)
     return schemas.Response(success=True)
 
 
-@router.get("/", summary="微信验证")
-def wechat_verify(echostr: str, msg_signature: str,
-                  timestamp: Union[str, int], nonce: str) -> Any:
+@router.post("/web", summary="接收WEB消息", response_model=schemas.Response)
+def web_message(text: str, current_user: User = Depends(get_current_active_superuser)):
     """
-    用户消息响应
+    WEB消息响应
     """
-    logger.info(f"收到微信验证请求: {echostr}")
+    MessageChain().handle_message(
+        channel=MessageChannel.Web,
+        source=current_user.name,
+        userid=current_user.name,
+        username=current_user.name,
+        text=text
+    )
+    return schemas.Response(success=True)
+
+
+@router.get("/web", summary="获取WEB消息", response_model=List[dict])
+def get_web_message(_: schemas.TokenPayload = Depends(verify_token),
+                    db: Session = Depends(get_db),
+                    page: Optional[int] = 1,
+                    count: Optional[int] = 20):
+    """
+    获取WEB消息列表
+    """
+    ret_messages = []
+    messages = Message.list_by_page(db, page=page, count=count)
+    for message in messages:
+        try:
+            ret_messages.append(message.to_dict())
+        except Exception as e:
+            logger.error(f"获取WEB消息列表失败: {str(e)}")
+            continue
+    return ret_messages
+
+
+def wechat_verify(echostr: str, msg_signature: str, timestamp: Union[str, int], nonce: str,
+                  source: Optional[str] = None) -> Any:
+    """
+    微信验证响应
+    """
+    # 获取服务配置
+    client_configs = ServiceConfigHelper.get_notification_configs()
+    if not client_configs:
+        return "未找到对应的消息配置"
+    client_config = next((config for config in client_configs if
+                          config.type == "wechat" and config.enabled and (not source or config.name == source)), None)
+    if not client_config:
+        return "未找到对应的消息配置"
     try:
-        wxcpt = WXBizMsgCrypt(sToken=settings.WECHAT_TOKEN,
-                              sEncodingAESKey=settings.WECHAT_ENCODING_AESKEY,
-                              sReceiveId=settings.WECHAT_CORPID)
+        wxcpt = WXBizMsgCrypt(sToken=client_config.config.get('WECHAT_TOKEN'),
+                              sEncodingAESKey=client_config.config.get('WECHAT_ENCODING_AESKEY'),
+                              sReceiveId=client_config.config.get('WECHAT_CORPID'))
+        ret, sEchoStr = wxcpt.VerifyURL(sMsgSignature=msg_signature,
+                                        sTimeStamp=timestamp,
+                                        sNonce=nonce,
+                                        sEchoStr=echostr)
+        if ret == 0:
+            # 验证URL成功，将sEchoStr返回给企业号
+            return PlainTextResponse(sEchoStr)
+        return "微信验证失败"
     except Exception as err:
-        logger.error(f"微信请求验证失败: {err}")
+        logger.error(f"微信请求验证失败: {str(err)}")
         return str(err)
-    ret, sEchoStr = wxcpt.VerifyURL(sMsgSignature=msg_signature,
-                                    sTimeStamp=timestamp,
-                                    sNonce=nonce,
-                                    sEchoStr=echostr)
-    if ret != 0:
-        logger.error("微信请求验证失败 VerifyURL ret: %s" % str(ret))
-    # 验证URL成功，将sEchoStr返回给企业号
-    return PlainTextResponse(sEchoStr)
 
 
-@router.get("/switchs", summary="查询通知消息渠道开关", response_model=List[NotificationSwitch])
-def read_switchs(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def vocechat_verify() -> Any:
     """
-    查询通知消息渠道开关
+    VoceChat验证响应
     """
-    return_list = []
-    # 读取数据库
-    switchs = SystemConfigOper().get(SystemConfigKey.NotificationChannels)
-    if not switchs:
-        for noti in NotificationType:
-            return_list.append(NotificationSwitch(mtype=noti.value, wechat=True,
-                                                  telegram=True, slack=True,
-                                                  synologychat=True))
-    else:
-        for switch in switchs:
-            return_list.append(NotificationSwitch(**switch))
-    return return_list
+    return {"status": "OK"}
 
 
-@router.post("/switchs", summary="设置通知消息渠道开关", response_model=schemas.Response)
-def set_switchs(switchs: List[NotificationSwitch],
-                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get("/", summary="回调请求验证")
+def incoming_verify(token: Optional[str] = None, echostr: Optional[str] = None, msg_signature: Optional[str] = None,
+                    timestamp: Union[str, int] = None, nonce: Optional[str] = None, source: Optional[str] = None,
+                    _: schemas.TokenPayload = Depends(verify_apitoken)) -> Any:
     """
-    查询通知消息渠道开关
+    微信/VoceChat等验证响应
     """
-    switch_list = []
-    for switch in switchs:
-        switch_list.append(switch.dict())
-    # 存入数据库
-    SystemConfigOper().set(SystemConfigKey.NotificationChannels, switch_list)
+    logger.info(f"收到验证请求: token={token}, echostr={echostr}, "
+                f"msg_signature={msg_signature}, timestamp={timestamp}, nonce={nonce}")
+    if echostr and msg_signature and timestamp and nonce:
+        return wechat_verify(echostr, msg_signature, timestamp, nonce, source)
+    return vocechat_verify()
 
+
+@router.post("/webpush/subscribe", summary="客户端webpush通知订阅", response_model=schemas.Response)
+def subscribe(subscription: schemas.Subscription, _: schemas.TokenPayload = Depends(verify_token)):
+    """
+    客户端webpush通知订阅
+    """
+    subinfo = subscription.dict()
+    if subinfo not in global_vars.get_subscriptions():
+        global_vars.push_subscription(subinfo)
+    logger.debug(f"通知订阅成功: {subinfo}")
+    return schemas.Response(success=True)
+
+
+@router.post("/webpush/send", summary="发送webpush通知", response_model=schemas.Response)
+def send_notification(payload: schemas.SubscriptionMessage, _: schemas.TokenPayload = Depends(verify_token)):
+    """
+    发送webpush通知
+    """
+    for sub in global_vars.get_subscriptions():
+        try:
+            webpush(
+                subscription_info=sub,
+                data=json.dumps(payload.dict()),
+                vapid_private_key=settings.VAPID.get("privateKey"),
+                vapid_claims={
+                    "sub": settings.VAPID.get("subject")
+                },
+            )
+        except WebPushException as err:
+            logger.error(f"WebPush发送失败: {str(err)}")
+            continue
     return schemas.Response(success=True)

app/api/endpoints/plugin.py

@@ -1,73 +1,450 @@
-from typing import Any, List
+import mimetypes
+import shutil
+from typing import Annotated, Any, List, Optional
 
-from fastapi import APIRouter, Depends
+from fastapi import APIRouter, Depends, Header, HTTPException
+from starlette import status
+from starlette.responses import FileResponse
 
 from app import schemas
+from app.command import Command
+from app.core.config import settings
 from app.core.plugin import PluginManager
-from app.core.security import verify_token
+from app.core.security import verify_apikey, verify_token
 from app.db.systemconfig_oper import SystemConfigOper
+from app.db.user_oper import get_current_active_superuser
+from app.factory import app
+from app.helper.plugin import PluginHelper
+from app.log import logger
+from app.scheduler import Scheduler
 from app.schemas.types import SystemConfigKey
 
+PROTECTED_ROUTES = {"/api/v1/openapi.json", "/docs", "/docs/oauth2-redirect", "/redoc"}
+PLUGIN_PREFIX = f"{settings.API_V1_STR}/plugin"
+
 router = APIRouter()
 
 
+def register_plugin_api(plugin_id: Optional[str] = None):
+    """
+    动态注册插件 API
+    :param plugin_id: 插件 ID，如果为 None，则注册所有插件
+    """
+    _update_plugin_api_routes(plugin_id, action="add")
+
+
+def remove_plugin_api(plugin_id: str):
+    """
+    动态移除单个插件的 API
+    :param plugin_id: 插件 ID
+    """
+    _update_plugin_api_routes(plugin_id, action="remove")
+
+
+def _update_plugin_api_routes(plugin_id: Optional[str], action: str):
+    """
+    插件 API 路由注册和移除
+    :param plugin_id: 插件 ID，如果 action 为 "add" 且 plugin_id 为 None，则处理所有插件
+                      如果 action 为 "remove"，plugin_id 必须是有效的插件 ID
+    :param action: "add" 或 "remove"，决定是添加还是移除路由
+    """
+    if action not in {"add", "remove"}:
+        raise ValueError("Action must be 'add' or 'remove'")
+
+    is_modified = False
+    existing_paths = {route.path: route for route in app.routes}
+
+    plugin_ids = [plugin_id] if plugin_id else PluginManager().get_running_plugin_ids()
+    for plugin_id in plugin_ids:
+        routes_removed = _remove_routes(plugin_id)
+        if routes_removed:
+            is_modified = True
+
+        if action != "add":
+            continue
+        # 获取插件的 API 路由信息
+        plugin_apis = PluginManager().get_plugin_apis(plugin_id)
+        for api in plugin_apis:
+            api_path = f"{PLUGIN_PREFIX}{api.get('path', '')}"
+            try:
+                api["path"] = api_path
+                allow_anonymous = api.pop("allow_anonymous", False)
+                auth_mode = api.pop("auth", "apikey")
+                dependencies = api.setdefault("dependencies", [])
+                if not allow_anonymous:
+                    if auth_mode == "bear" and Depends(verify_token) not in dependencies:
+                        dependencies.append(Depends(verify_token))
+                    elif Depends(verify_apikey) not in dependencies:
+                        dependencies.append(Depends(verify_apikey))
+                app.add_api_route(**api, tags=["plugin"])
+                is_modified = True
+                logger.debug(f"Added plugin route: {api_path}")
+            except Exception as e:
+                logger.error(f"Error adding plugin route {api_path}: {str(e)}")
+
+    if is_modified:
+        _clean_protected_routes(existing_paths)
+        app.openapi_schema = None
+        app.setup()
+
+
+def _remove_routes(plugin_id: str) -> bool:
+    """
+    移除与单个插件相关的路由
+    :param plugin_id: 插件 ID
+    :return: 是否有路由被移除
+    """
+    if not plugin_id:
+        return False
+    prefix = f"{PLUGIN_PREFIX}/{plugin_id}/"
+    routes_to_remove = [route for route in app.routes if route.path.startswith(prefix)]
+    removed = False
+    for route in routes_to_remove:
+        try:
+            app.routes.remove(route)
+            removed = True
+            logger.debug(f"Removed plugin route: {route.path}")
+        except Exception as e:
+            logger.error(f"Error removing plugin route {route.path}: {str(e)}")
+    return removed
+
+
+def _clean_protected_routes(existing_paths: dict):
+    """
+    清理受保护的路由，防止在插件操作中被删除或重复添加
+    :param existing_paths: 当前应用的路由路径映射
+    """
+    for protected_route in PROTECTED_ROUTES:
+        try:
+            existing_route = existing_paths.get(protected_route)
+            if existing_route:
+                app.routes.remove(existing_route)
+        except Exception as e:
+            logger.error(f"Error removing protected route {protected_route}: {str(e)}")
+
+
+def register_plugin(plugin_id: str):
+    """
+    注册一个插件相关的服务
+    """
+    # 注册插件服务
+    Scheduler().update_plugin_job(plugin_id)
+    # 注册菜单命令
+    Command().init_commands(plugin_id)
+    # 注册插件API
+    register_plugin_api(plugin_id)
+
+
 @router.get("/", summary="所有插件", response_model=List[schemas.Plugin])
-def all_plugins(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def all_plugins(_: schemas.TokenPayload = Depends(get_current_active_superuser),
+                state: Optional[str] = "all", force: bool = False) -> List[schemas.Plugin]:
     """
-    查询所有插件清单
+    查询所有插件清单，包括本地插件和在线插件，插件状态：installed, market, all
     """
-    return PluginManager().get_plugin_apps()
+    # 本地插件
+    local_plugins = PluginManager().get_local_plugins()
+    # 已安装插件
+    installed_plugins = [plugin for plugin in local_plugins if plugin.installed]
+    if state == "installed":
+        return installed_plugins
+
+    # 未安装的本地插件
+    not_installed_plugins = [plugin for plugin in local_plugins if not plugin.installed]
+    # 在线插件
+    online_plugins = PluginManager().get_online_plugins(force)
+    if not online_plugins:
+        # 没有获取在线插件
+        if state == "market":
+            # 返回未安装的本地插件
+            return not_installed_plugins
+        return local_plugins
+
+    # 插件市场插件清单
+    market_plugins = []
+    # 已安装插件IDS
+    _installed_ids = [plugin.id for plugin in installed_plugins]
+    # 未安装的线上插件或者有更新的插件
+    for plugin in online_plugins:
+        if plugin.id not in _installed_ids:
+            market_plugins.append(plugin)
+        elif plugin.has_update:
+            market_plugins.append(plugin)
+    # 未安装的本地插件，且不在线上插件中
+    _plugin_ids = [plugin.id for plugin in market_plugins]
+    for plugin in not_installed_plugins:
+        if plugin.id not in _plugin_ids:
+            market_plugins.append(plugin)
+    # 返回插件清单
+    if state == "market":
+        # 返回未安装的插件
+        return market_plugins
+
+    # 返回所有插件
+    return installed_plugins + market_plugins
 
 
 @router.get("/installed", summary="已安装插件", response_model=List[str])
-def installed_plugins(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def installed(_: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
     """
     查询用户已安装插件清单
     """
     return SystemConfigOper().get(SystemConfigKey.UserInstalledPlugins) or []
 
 
+@router.get("/statistic", summary="插件安装统计", response_model=dict)
+def statistic(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    插件安装统计
+    """
+    return PluginHelper().get_statistic()
+
+
+@router.get("/reload/{plugin_id}", summary="重新加载插件", response_model=schemas.Response)
+def reload_plugin(plugin_id: str, _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    重新加载插件
+    """
+    # 重新加载插件
+    PluginManager().reload_plugin(plugin_id)
+    # 注册插件服务
+    register_plugin(plugin_id)
+    return schemas.Response(success=True)
+
+
 @router.get("/install/{plugin_id}", summary="安装插件", response_model=schemas.Response)
-def install_plugin(plugin_id: str,
-                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def install(plugin_id: str,
+            repo_url: Optional[str] = "",
+            force: Optional[bool] = False,
+            _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
     """
     安装插件
     """
     # 已安装插件
     install_plugins = SystemConfigOper().get(SystemConfigKey.UserInstalledPlugins) or []
+    # 首先检查插件是否已经存在，并且是否强制安装，否则只进行安装统计
+    if not force and plugin_id in PluginManager().get_plugin_ids():
+        PluginHelper().install_reg(pid=plugin_id)
+    else:
+        # 插件不存在或需要强制安装，下载安装并注册插件
+        if repo_url:
+            state, msg = PluginHelper().install(pid=plugin_id, repo_url=repo_url)
+            # 安装失败则直接响应
+            if not state:
+                return schemas.Response(success=False, message=msg)
+        else:
+            # repo_url 为空时，也直接响应
+            return schemas.Response(success=False, message="没有传入仓库地址，无法正确安装插件，请检查配置")
     # 安装插件
     if plugin_id not in install_plugins:
         install_plugins.append(plugin_id)
         # 保存设置
         SystemConfigOper().set(SystemConfigKey.UserInstalledPlugins, install_plugins)
-        # 重载插件管理器
-        PluginManager().init_config()
+    # 重新加载插件
+    reload_plugin(plugin_id)
     return schemas.Response(success=True)
 
 
+@router.get("/remotes", summary="获取插件联邦组件列表", response_model=List[dict])
+def remotes(token: str) -> Any:
+    """
+    获取插件联邦组件列表
+    """
+    if token != "moviepilot":
+        raise HTTPException(status_code=403, detail="Forbidden")
+    return PluginManager().get_plugin_remotes()
+
+
 @router.get("/form/{plugin_id}", summary="获取插件表单页面")
 def plugin_form(plugin_id: str,
-                _: schemas.TokenPayload = Depends(verify_token)) -> dict:
+                _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> dict:
     """
-    根据插件ID获取插件配置表单
+    根据插件ID获取插件配置表单或Vue组件URL
     """
-    conf, model = PluginManager().get_plugin_form(plugin_id)
-    return {
-        "conf": conf,
-        "model": model
-    }
+    plugin_instance = PluginManager().running_plugins.get(plugin_id)
+    if not plugin_instance:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"插件 {plugin_id} 不存在或未加载")
+
+    # 渲染模式
+    render_mode, _ = plugin_instance.get_render_mode()
+    try:
+        conf, model = plugin_instance.get_form()
+        return {
+            "render_mode": render_mode,
+            "conf": conf,
+            "model": PluginManager().get_plugin_config(plugin_id) or model
+        }
+    except Exception as e:
+        logger.error(f"插件 {plugin_id} 调用方法 get_form 出错: {str(e)}")
+    return {}
 
 
 @router.get("/page/{plugin_id}", summary="获取插件数据页面")
-def plugin_page(plugin_id: str, _: schemas.TokenPayload = Depends(verify_token)) -> List[dict]:
+def plugin_page(plugin_id: str, _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> dict:
     """
-    根据插件ID获取插件配置信息
+    根据插件ID获取插件数据页面
     """
-    return PluginManager().get_plugin_page(plugin_id)
+    plugin_instance = PluginManager().running_plugins.get(plugin_id)
+    if not plugin_instance:
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"插件 {plugin_id} 不存在或未加载")
+
+    # 渲染模式
+    render_mode, _ = plugin_instance.get_render_mode()
+    try:
+        page = plugin_instance.get_page()
+        return {
+            "render_mode": render_mode,
+            "page": page or []
+        }
+    except Exception as e:
+        logger.error(f"插件 {plugin_id} 调用方法 get_page 出错: {str(e)}")
+    return {}
+
+
+@router.get("/dashboard/meta", summary="获取所有插件仪表板元信息")
+def plugin_dashboard_meta(_: schemas.TokenPayload = Depends(verify_token)) -> List[dict]:
+    """
+    获取所有插件仪表板元信息
+    """
+    return PluginManager().get_plugin_dashboard_meta()
+
+
+@router.get("/dashboard/{plugin_id}/{key}", summary="获取插件仪表板配置")
+def plugin_dashboard_by_key(plugin_id: str, key: str, user_agent: Annotated[str | None, Header()] = None,
+                            _: schemas.TokenPayload = Depends(verify_token)) -> Optional[schemas.PluginDashboard]:
+    """
+    根据插件ID获取插件仪表板
+    """
+    return PluginManager().get_plugin_dashboard(plugin_id, key, user_agent)
+
+
+@router.get("/dashboard/{plugin_id}", summary="获取插件仪表板配置")
+def plugin_dashboard(plugin_id: str, user_agent: Annotated[str | None, Header()] = None,
+                     _: schemas.TokenPayload = Depends(verify_token)) -> schemas.PluginDashboard:
+    """
+    根据插件ID获取插件仪表板
+    """
+    return plugin_dashboard_by_key(plugin_id, "", user_agent)
+
+
+@router.get("/reset/{plugin_id}", summary="重置插件配置及数据", response_model=schemas.Response)
+def reset_plugin(plugin_id: str,
+                 _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    根据插件ID重置插件配置及数据
+    """
+    plugin_manager = PluginManager()
+    # 删除配置
+    plugin_manager.delete_plugin_config(plugin_id)
+    # 删除插件所有数据
+    plugin_manager.delete_plugin_data(plugin_id)
+    # 重新加载插件
+    reload_plugin(plugin_id)
+    return schemas.Response(success=True)
+
+
+@router.get("/file/{plugin_id}/{filepath:path}", summary="获取插件静态文件")
+def plugin_static_file(plugin_id: str, filepath: str):
+    """
+    获取插件静态文件
+    """
+    # 基础安全检查
+    if ".." in filepath or ".." in plugin_id:
+        logger.warning(f"Static File API: Path traversal attempt detected: {plugin_id}/{filepath}")
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail="Forbidden")
+
+    plugin_base_dir = settings.ROOT_PATH / "app" / "plugins" / plugin_id.lower()
+    plugin_file_path = plugin_base_dir / filepath
+    if not plugin_file_path.exists():
+        raise HTTPException(status_code=status.HTTP_404_NOT_FOUND, detail=f"{plugin_file_path} 不存在")
+    if not plugin_file_path.is_file():
+        raise HTTPException(status_code=status.HTTP_403_FORBIDDEN, detail=f"{plugin_file_path} 不是文件")
+
+    # 判断 MIME 类型
+    response_type, _ = mimetypes.guess_type(str(plugin_file_path))
+    suffix = plugin_file_path.suffix.lower()
+    # 强制修正 .mjs 和 .js 的 MIME 类型
+    if suffix in ['.js', '.mjs']:
+        response_type = 'application/javascript'
+    elif suffix == '.css' and not response_type:  # 如果 guess_type 没猜对 css，也修正
+        response_type = 'text/css'
+    elif not response_type:  # 对于其他猜不出的类型
+        response_type = 'application/octet-stream'
+
+    try:
+        return FileResponse(plugin_file_path, media_type=response_type)
+    except Exception as e:
+        logger.error(f"Error creating/sending FileResponse for {plugin_file_path}: {e}", exc_info=True)
+        raise HTTPException(status_code=500, detail="Internal Server Error")
+
+
+@router.get("/folders", summary="获取插件文件夹配置", response_model=dict)
+def get_plugin_folders(_: schemas.TokenPayload = Depends(get_current_active_superuser)) -> dict:
+    """
+    获取插件文件夹分组配置
+    """
+    try:
+        result = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
+        return result
+    except Exception as e:
+        logger.error(f"[文件夹API] 获取文件夹配置失败: {str(e)}")
+        return {}
+
+
+@router.post("/folders", summary="保存插件文件夹配置", response_model=schemas.Response)
+def save_plugin_folders(folders: dict, _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    保存插件文件夹分组配置
+    """
+    try:
+        SystemConfigOper().set(SystemConfigKey.PluginFolders, folders)
+        return schemas.Response(success=True)
+    except Exception as e:
+        logger.error(f"[文件夹API] 保存文件夹配置失败: {str(e)}")
+        return schemas.Response(success=False, message=str(e))
+
+
+@router.post("/folders/{folder_name}", summary="创建插件文件夹", response_model=schemas.Response)
+def create_plugin_folder(folder_name: str, _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    创建新的插件文件夹
+    """
+    folders = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
+    if folder_name not in folders:
+        folders[folder_name] = []
+        SystemConfigOper().set(SystemConfigKey.PluginFolders, folders)
+        return schemas.Response(success=True, message=f"文件夹 '{folder_name}' 创建成功")
+    else:
+        return schemas.Response(success=False, message=f"文件夹 '{folder_name}' 已存在")
+
+
+@router.delete("/folders/{folder_name}", summary="删除插件文件夹", response_model=schemas.Response)
+def delete_plugin_folder(folder_name: str, _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    删除插件文件夹
+    """
+    folders = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
+    if folder_name in folders:
+        del folders[folder_name]
+        SystemConfigOper().set(SystemConfigKey.PluginFolders, folders)
+        return schemas.Response(success=True, message=f"文件夹 '{folder_name}' 删除成功")
+    else:
+        return schemas.Response(success=False, message=f"文件夹 '{folder_name}' 不存在")
+
+
+@router.put("/folders/{folder_name}/plugins", summary="更新文件夹中的插件", response_model=schemas.Response)
+def update_folder_plugins(folder_name: str, plugin_ids: List[str], _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    更新指定文件夹中的插件列表
+    """
+    folders = SystemConfigOper().get(SystemConfigKey.PluginFolders) or {}
+    folders[folder_name] = plugin_ids
+    SystemConfigOper().set(SystemConfigKey.PluginFolders, folders)
+    return schemas.Response(success=True, message=f"文件夹 '{folder_name}' 中的插件已更新")
 
 
 @router.get("/{plugin_id}", summary="获取插件配置")
-def plugin_config(plugin_id: str, _: schemas.TokenPayload = Depends(verify_token)) -> dict:
+def plugin_config(plugin_id: str,
+                  _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> dict:
     """
     根据插件ID获取插件配置信息
     """
@@ -76,36 +453,173 @@ def plugin_config(plugin_id: str, _: schemas.TokenPayload = Depends(verify_token
 
 @router.put("/{plugin_id}", summary="更新插件配置", response_model=schemas.Response)
 def set_plugin_config(plugin_id: str, conf: dict,
-                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+                      _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
     """
-    根据插件ID获取插件配置信息
+    更新插件配置
     """
+    plugin_manager = PluginManager()
     # 保存配置
-    PluginManager().save_plugin_config(plugin_id, conf)
+    plugin_manager.save_plugin_config(plugin_id, conf)
     # 重新生效插件
-    PluginManager().reload_plugin(plugin_id, conf)
+    plugin_manager.init_plugin(plugin_id, conf)
+    # 注册插件服务
+    register_plugin(plugin_id)
     return schemas.Response(success=True)
 
 
 @router.delete("/{plugin_id}", summary="卸载插件", response_model=schemas.Response)
 def uninstall_plugin(plugin_id: str,
-                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+                     _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
     """
     卸载插件
     """
+    config_oper = SystemConfigOper()
     # 删除已安装信息
-    install_plugins = SystemConfigOper().get(SystemConfigKey.UserInstalledPlugins) or []
+    install_plugins = config_oper.get(SystemConfigKey.UserInstalledPlugins) or []
     for plugin in install_plugins:
         if plugin == plugin_id:
             install_plugins.remove(plugin)
             break
-    # 保存
-    SystemConfigOper().set(SystemConfigKey.UserInstalledPlugins, install_plugins)
-    # 重载插件管理器
-    PluginManager().init_config()
+    config_oper.set(SystemConfigKey.UserInstalledPlugins, install_plugins)
+    # 移除插件API
+    remove_plugin_api(plugin_id)
+    # 移除插件服务
+    Scheduler().remove_plugin_job(plugin_id)
+    # 判断是否为分身
+    plugin_manager = PluginManager()
+    plugin_class = plugin_manager.plugins.get(plugin_id)
+    if getattr(plugin_class, "is_clone", False):
+        # 如果是分身插件，则删除分身数据和配置
+        plugin_manager.delete_plugin_config(plugin_id)
+        plugin_manager.delete_plugin_data(plugin_id)
+        # 删除分身文件
+        plugin_base_dir = settings.ROOT_PATH / "app" / "plugins" / plugin_id.lower()
+        if plugin_base_dir.exists():
+            try:
+                shutil.rmtree(plugin_base_dir)
+                plugin_manager.plugins.pop(plugin_id, None)
+            except Exception as e:
+                logger.error(f"删除插件分身目录 {plugin_base_dir} 失败: {str(e)}")
+    # 从插件文件夹中移除该插件
+    _remove_plugin_from_folders(plugin_id)
+    # 移除插件
+    plugin_manager.remove_plugin(plugin_id)
     return schemas.Response(success=True)
 
 
-# 注册插件API
-for api in PluginManager().get_plugin_apis():
-    router.add_api_route(**api)
+@router.post("/clone/{plugin_id}", summary="创建插件分身", response_model=schemas.Response)
+def clone_plugin(plugin_id: str,
+                 clone_data: dict,
+                 _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    创建插件分身
+    """
+    try:
+        success, message = PluginManager().clone_plugin(
+            plugin_id=plugin_id,
+            suffix=clone_data.get("suffix", ""),
+            name=clone_data.get("name", ""),
+            description=clone_data.get("description", ""),
+            version=clone_data.get("version", ""),
+            icon=clone_data.get("icon", "")
+        )
+
+        if success:
+            # 注册插件服务
+            reload_plugin(message)
+            # 将分身插件添加到原插件所在的文件夹中
+            _add_clone_to_plugin_folder(plugin_id, message)
+            return schemas.Response(success=True, message="插件分身创建成功")
+        else:
+            return schemas.Response(success=False, message=message)
+    except Exception as e:
+        logger.error(f"创建插件分身失败：{str(e)}")
+        return schemas.Response(success=False, message=f"创建插件分身失败：{str(e)}")
+
+
+def _add_clone_to_plugin_folder(original_plugin_id: str, clone_plugin_id: str):
+    """
+    将分身插件添加到原插件所在的文件夹中
+    :param original_plugin_id: 原插件ID
+    :param clone_plugin_id: 分身插件ID
+    """
+    try:
+        config_oper = SystemConfigOper()
+        # 获取插件文件夹配置
+        folders = config_oper.get(SystemConfigKey.PluginFolders) or {}
+
+        # 查找原插件所在的文件夹
+        target_folder = None
+        for folder_name, folder_data in folders.items():
+            if isinstance(folder_data, dict) and 'plugins' in folder_data:
+                # 新格式：{"plugins": [...], "order": ..., "icon": ...}
+                if original_plugin_id in folder_data['plugins']:
+                    target_folder = folder_name
+                    break
+            elif isinstance(folder_data, list):
+                # 旧格式：直接是插件列表
+                if original_plugin_id in folder_data:
+                    target_folder = folder_name
+                    break
+
+        # 如果找到了原插件所在的文件夹，则将分身插件也添加到该文件夹中
+        if target_folder:
+            folder_data = folders[target_folder]
+            if isinstance(folder_data, dict) and 'plugins' in folder_data:
+                # 新格式
+                if clone_plugin_id not in folder_data['plugins']:
+                    folder_data['plugins'].append(clone_plugin_id)
+                    logger.info(f"已将分身插件 {clone_plugin_id} 添加到文件夹 '{target_folder}' 中")
+            elif isinstance(folder_data, list):
+                # 旧格式
+                if clone_plugin_id not in folder_data:
+                    folder_data.append(clone_plugin_id)
+                    logger.info(f"已将分身插件 {clone_plugin_id} 添加到文件夹 '{target_folder}' 中")
+
+            # 保存更新后的文件夹配置
+            config_oper.set(SystemConfigKey.PluginFolders, folders)
+        else:
+            logger.info(f"原插件 {original_plugin_id} 不在任何文件夹中，分身插件 {clone_plugin_id} 将保持独立")
+
+    except Exception as e:
+        logger.error(f"处理插件文件夹时出错：{str(e)}")
+        # 文件夹处理失败不影响插件分身创建的整体流程
+
+
+def _remove_plugin_from_folders(plugin_id: str):
+    """
+    从所有文件夹中移除指定的插件
+    :param plugin_id: 要移除的插件ID
+    """
+    try:
+        config_oper = SystemConfigOper()
+        # 获取插件文件夹配置
+        folders = config_oper.get(SystemConfigKey.PluginFolders) or {}
+
+        # 标记是否有修改
+        modified = False
+
+        # 遍历所有文件夹，移除指定插件
+        for folder_name, folder_data in folders.items():
+            if isinstance(folder_data, dict) and 'plugins' in folder_data:
+                # 新格式：{"plugins": [...], "order": ..., "icon": ...}
+                if plugin_id in folder_data['plugins']:
+                    folder_data['plugins'].remove(plugin_id)
+                    logger.info(f"已从文件夹 '{folder_name}' 中移除插件 {plugin_id}")
+                    modified = True
+            elif isinstance(folder_data, list):
+                # 旧格式：直接是插件列表
+                if plugin_id in folder_data:
+                    folder_data.remove(plugin_id)
+                    logger.info(f"已从文件夹 '{folder_name}' 中移除插件 {plugin_id}")
+                    modified = True
+
+        # 如果有修改，保存更新后的文件夹配置
+        if modified:
+            config_oper.set(SystemConfigKey.PluginFolders, folders)
+        else:
+            logger.debug(f"插件 {plugin_id} 不在任何文件夹中，无需移除")
+
+    except Exception as e:
+        logger.error(f"从文件夹中移除插件时出错：{str(e)}")
+        # 文件夹处理失败不影响插件卸载的整体流程

app/api/endpoints/recommend.py

@@ -0,0 +1,191 @@
+from typing import Any, List, Optional
+
+from fastapi import APIRouter, Depends
+
+from app import schemas
+from app.core.event import eventmanager
+from app.core.security import verify_token
+from app.schemas.types import ChainEventType
+from app.chain.recommend import RecommendChain
+from app.schemas import RecommendSourceEventData
+
+router = APIRouter()
+
+
+@router.get("/source", summary="获取推荐数据源", response_model=List[schemas.RecommendMediaSource])
+def source(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    获取推荐数据源
+    """
+    # 广播事件，请示额外的推荐数据源支持
+    event_data = RecommendSourceEventData()
+    event = eventmanager.send_event(ChainEventType.RecommendSource, event_data)
+    # 使用事件返回的上下文数据
+    if event and event.event_data:
+        event_data: RecommendSourceEventData = event.event_data
+        if event_data.extra_sources:
+            return event_data.extra_sources
+    return []
+
+
+@router.get("/bangumi_calendar", summary="Bangumi每日放送", response_model=List[schemas.MediaInfo])
+def bangumi_calendar(page: Optional[int] = 1,
+                     count: Optional[int] = 30,
+                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览Bangumi每日放送
+    """
+    return RecommendChain().bangumi_calendar(page=page, count=count)
+
+
+@router.get("/douban_showing", summary="豆瓣正在热映", response_model=List[schemas.MediaInfo])
+def douban_showing(page: Optional[int] = 1,
+                   count: Optional[int] = 30,
+                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣正在热映
+    """
+    return RecommendChain().douban_movie_showing(page=page, count=count)
+
+
+@router.get("/douban_movies", summary="豆瓣电影", response_model=List[schemas.MediaInfo])
+def douban_movies(sort: Optional[str] = "R",
+                  tags: Optional[str] = "",
+                  page: Optional[int] = 1,
+                  count: Optional[int] = 30,
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣电影信息
+    """
+    return RecommendChain().douban_movies(sort=sort, tags=tags, page=page, count=count)
+
+
+@router.get("/douban_tvs", summary="豆瓣剧集", response_model=List[schemas.MediaInfo])
+def douban_tvs(sort: Optional[str] = "R",
+               tags: Optional[str] = "",
+               page: Optional[int] = 1,
+               count: Optional[int] = 30,
+               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣剧集信息
+    """
+    return RecommendChain().douban_tvs(sort=sort, tags=tags, page=page, count=count)
+
+
+@router.get("/douban_movie_top250", summary="豆瓣电影TOP250", response_model=List[schemas.MediaInfo])
+def douban_movie_top250(page: Optional[int] = 1,
+                        count: Optional[int] = 30,
+                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览豆瓣剧集信息
+    """
+    return RecommendChain().douban_movie_top250(page=page, count=count)
+
+
+@router.get("/douban_tv_weekly_chinese", summary="豆瓣国产剧集周榜", response_model=List[schemas.MediaInfo])
+def douban_tv_weekly_chinese(page: Optional[int] = 1,
+                             count: Optional[int] = 30,
+                             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    中国每周剧集口碑榜
+    """
+    return RecommendChain().douban_tv_weekly_chinese(page=page, count=count)
+
+
+@router.get("/douban_tv_weekly_global", summary="豆瓣全球剧集周榜", response_model=List[schemas.MediaInfo])
+def douban_tv_weekly_global(page: Optional[int] = 1,
+                            count: Optional[int] = 30,
+                            _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    全球每周剧集口碑榜
+    """
+    return RecommendChain().douban_tv_weekly_global(page=page, count=count)
+
+
+@router.get("/douban_tv_animation", summary="豆瓣动画剧集", response_model=List[schemas.MediaInfo])
+def douban_tv_animation(page: Optional[int] = 1,
+                        count: Optional[int] = 30,
+                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    热门动画剧集
+    """
+    return RecommendChain().douban_tv_animation(page=page, count=count)
+
+
+@router.get("/douban_movie_hot", summary="豆瓣热门电影", response_model=List[schemas.MediaInfo])
+def douban_movie_hot(page: Optional[int] = 1,
+                     count: Optional[int] = 30,
+                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    热门电影
+    """
+    return RecommendChain().douban_movie_hot(page=page, count=count)
+
+
+@router.get("/douban_tv_hot", summary="豆瓣热门电视剧", response_model=List[schemas.MediaInfo])
+def douban_tv_hot(page: Optional[int] = 1,
+                  count: Optional[int] = 30,
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    热门电视剧
+    """
+    return RecommendChain().douban_tv_hot(page=page, count=count)
+
+
+@router.get("/tmdb_movies", summary="TMDB电影", response_model=List[schemas.MediaInfo])
+def tmdb_movies(sort_by: Optional[str] = "popularity.desc",
+                with_genres: Optional[str] = "",
+                with_original_language: Optional[str] = "",
+                with_keywords: Optional[str] = "",
+                with_watch_providers: Optional[str] = "",
+                vote_average: Optional[float] = 0.0,
+                vote_count: Optional[int] = 0,
+                release_date: Optional[str] = "",
+                page: Optional[int] = 1,
+                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览TMDB电影信息
+    """
+    return RecommendChain().tmdb_movies(sort_by=sort_by,
+                                        with_genres=with_genres,
+                                        with_original_language=with_original_language,
+                                        with_keywords=with_keywords,
+                                        with_watch_providers=with_watch_providers,
+                                        vote_average=vote_average,
+                                        vote_count=vote_count,
+                                        release_date=release_date,
+                                        page=page)
+
+
+@router.get("/tmdb_tvs", summary="TMDB剧集", response_model=List[schemas.MediaInfo])
+def tmdb_tvs(sort_by: Optional[str] = "popularity.desc",
+             with_genres: Optional[str] = "",
+             with_original_language: Optional[str] = "",
+             with_keywords: Optional[str] = "",
+             with_watch_providers: Optional[str] = "",
+             vote_average: Optional[float] = 0.0,
+             vote_count: Optional[int] = 0,
+             release_date: Optional[str] = "",
+             page: Optional[int] = 1,
+             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    浏览TMDB剧集信息
+    """
+    return RecommendChain().tmdb_tvs(sort_by=sort_by,
+                                     with_genres=with_genres,
+                                     with_original_language=with_original_language,
+                                     with_keywords=with_keywords,
+                                     with_watch_providers=with_watch_providers,
+                                     vote_average=vote_average,
+                                     vote_count=vote_count,
+                                     release_date=release_date,
+                                     page=page)
+
+
+@router.get("/tmdb_trending", summary="TMDB流行趋势", response_model=List[schemas.MediaInfo])
+def tmdb_trending(page: Optional[int] = 1,
+                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    TMDB流行趋势
+    """
+    return RecommendChain().tmdb_trending(page=page)

app/api/endpoints/search.py

@@ -1,64 +1,161 @@
-from typing import List, Any
+from typing import List, Any, Optional
 
 from fastapi import APIRouter, Depends
-from sqlalchemy.orm import Session
 
 from app import schemas
-from app.chain.douban import DoubanChain
+from app.chain.media import MediaChain
 from app.chain.search import SearchChain
+from app.core.config import settings
+from app.core.event import eventmanager
+from app.core.metainfo import MetaInfo
 from app.core.security import verify_token
-from app.db import get_db
-from app.schemas.types import MediaType
+from app.schemas import MediaRecognizeConvertEventData
+from app.schemas.types import MediaType, ChainEventType
 
 router = APIRouter()
 
 
 @router.get("/last", summary="查询搜索结果", response_model=List[schemas.Context])
-async def search_latest(db: Session = Depends(get_db),
-                        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def search_latest(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询搜索结果
     """
-    torrents = SearchChain(db).last_search_results()
+    torrents = SearchChain().last_search_results()
     return [torrent.to_dict() for torrent in torrents]
 
 
-@router.get("/media/{mediaid}", summary="精确搜索资源", response_model=List[schemas.Context])
-def search_by_tmdbid(mediaid: str,
-                     mtype: str = None,
-                     area: str = "title",
-                     db: Session = Depends(get_db),
-                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get("/media/{mediaid}", summary="精确搜索资源", response_model=schemas.Response)
+def search_by_id(mediaid: str,
+                 mtype: Optional[str] = None,
+                 area: Optional[str] = "title",
+                 title: Optional[str] = None,
+                 year: Optional[str] = None,
+                 season: Optional[str] = None,
+                 sites: Optional[str] = None,
+                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    根据TMDBID/豆瓣ID精确搜索站点资源 tmdb:/douban:/
+    根据TMDBID/豆瓣ID精确搜索站点资源 tmdb:/douban:/bangumi:
     """
+    if mtype:
+        media_type = MediaType(mtype)
+    else:
+        media_type = None
+    if season:
+        media_season = int(season)
+    else:
+        media_season = None
+    if sites:
+        site_list = [int(site) for site in sites.split(",") if site]
+    else:
+        site_list = None
+    torrents = None
+    # 根据前缀识别媒体ID
     if mediaid.startswith("tmdb:"):
         tmdbid = int(mediaid.replace("tmdb:", ""))
-        if mtype:
-            mtype = MediaType(mtype)
-        torrents = SearchChain(db).search_by_tmdbid(tmdbid=tmdbid, mtype=mtype, area=area)
+        if settings.RECOGNIZE_SOURCE == "douban":
+            # 通过TMDBID识别豆瓣ID
+            doubaninfo = MediaChain().get_doubaninfo_by_tmdbid(tmdbid=tmdbid, mtype=media_type)
+            if doubaninfo:
+                torrents = SearchChain().search_by_id(doubanid=doubaninfo.get("id"),
+                                                      mtype=media_type, area=area, season=media_season,
+                                                      sites=site_list, cache_local=True)
+            else:
+                return schemas.Response(success=False, message="未识别到豆瓣媒体信息")
+        else:
+            torrents = SearchChain().search_by_id(tmdbid=tmdbid, mtype=media_type, area=area, season=media_season,
+                                                  sites=site_list, cache_local=True)
     elif mediaid.startswith("douban:"):
         doubanid = mediaid.replace("douban:", "")
-        # 识别豆瓣信息
-        context = DoubanChain(db).recognize_by_doubanid(doubanid)
-        if not context or not context.media_info or not context.media_info.tmdb_id:
-            return []
-        torrents = SearchChain(db).search_by_tmdbid(tmdbid=context.media_info.tmdb_id,
-                                                    mtype=context.media_info.type,
-                                                    area=area)
+        if settings.RECOGNIZE_SOURCE == "themoviedb":
+            # 通过豆瓣ID识别TMDBID
+            tmdbinfo = MediaChain().get_tmdbinfo_by_doubanid(doubanid=doubanid, mtype=media_type)
+            if tmdbinfo:
+                if tmdbinfo.get('season') and not media_season:
+                    media_season = tmdbinfo.get('season')
+                torrents = SearchChain().search_by_id(tmdbid=tmdbinfo.get("id"),
+                                                      mtype=media_type, area=area, season=media_season,
+                                                      sites=site_list, cache_local=True)
+            else:
+                return schemas.Response(success=False, message="未识别到TMDB媒体信息")
+        else:
+            torrents = SearchChain().search_by_id(doubanid=doubanid, mtype=media_type, area=area, season=media_season,
+                                                  sites=site_list, cache_local=True)
+    elif mediaid.startswith("bangumi:"):
+        bangumiid = int(mediaid.replace("bangumi:", ""))
+        if settings.RECOGNIZE_SOURCE == "themoviedb":
+            # 通过BangumiID识别TMDBID
+            tmdbinfo = MediaChain().get_tmdbinfo_by_bangumiid(bangumiid=bangumiid)
+            if tmdbinfo:
+                torrents = SearchChain().search_by_id(tmdbid=tmdbinfo.get("id"),
+                                                      mtype=media_type, area=area, season=media_season,
+                                                      sites=site_list, cache_local=True)
+            else:
+                return schemas.Response(success=False, message="未识别到TMDB媒体信息")
+        else:
+            # 通过BangumiID识别豆瓣ID
+            doubaninfo = MediaChain().get_doubaninfo_by_bangumiid(bangumiid=bangumiid)
+            if doubaninfo:
+                torrents = SearchChain().search_by_id(doubanid=doubaninfo.get("id"),
+                                                      mtype=media_type, area=area, season=media_season,
+                                                      sites=site_list, cache_local=True)
+            else:
+                return schemas.Response(success=False, message="未识别到豆瓣媒体信息")
     else:
-        return []
-    return [torrent.to_dict() for torrent in torrents]
+        # 未知前缀，广播事件解析媒体信息
+        event_data = MediaRecognizeConvertEventData(
+            mediaid=mediaid,
+            convert_type=settings.RECOGNIZE_SOURCE
+        )
+        event = eventmanager.send_event(ChainEventType.MediaRecognizeConvert, event_data)
+        # 使用事件返回的上下文数据
+        if event and event.event_data:
+            event_data: MediaRecognizeConvertEventData = event.event_data
+            if event_data.media_dict:
+                search_id = event_data.media_dict.get("id")
+                if event_data.convert_type == "themoviedb":
+                    torrents = SearchChain().search_by_id(tmdbid=search_id, mtype=media_type, area=area,
+                                                          season=media_season, cache_local=True)
+                elif event_data.convert_type == "douban":
+                    torrents = SearchChain().search_by_id(doubanid=search_id, mtype=media_type, area=area,
+                                                          season=media_season, cache_local=True)
+        else:
+            if not title:
+                return schemas.Response(success=False, message="未知的媒体ID")
+            # 使用名称识别兜底
+            meta = MetaInfo(title)
+            if year:
+                meta.year = year
+            if media_type:
+                meta.type = media_type
+            if media_season:
+                meta.type = MediaType.TV
+                meta.begin_season = media_season
+            mediainfo = MediaChain().recognize_media(meta=meta)
+            if mediainfo:
+                if settings.RECOGNIZE_SOURCE == "themoviedb":
+                    torrents = SearchChain().search_by_id(tmdbid=mediainfo.tmdb_id, mtype=media_type, area=area,
+                                                          season=media_season, cache_local=True)
+                else:
+                    torrents = SearchChain().search_by_id(doubanid=mediainfo.douban_id, mtype=media_type, area=area,
+                                                          season=media_season, cache_local=True)
+    # 返回搜索结果
+    if not torrents:
+        return schemas.Response(success=False, message="未搜索到任何资源")
+    else:
+        return schemas.Response(success=True, data=[torrent.to_dict() for torrent in torrents])
 
 
-@router.get("/title", summary="模糊搜索资源", response_model=List[schemas.TorrentInfo])
-async def search_by_title(keyword: str = None,
-                          page: int = 0,
-                          site: int = None,
-                          db: Session = Depends(get_db),
-                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get("/title", summary="模糊搜索资源", response_model=schemas.Response)
+def search_by_title(keyword: Optional[str] = None,
+                    page: Optional[int] = 0,
+                    sites: Optional[str] = None,
+                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据名称模糊搜索站点资源，支持分页，关键词为空是返回首页资源
     """
-    torrents = SearchChain(db).search_by_title(title=keyword, page=page, site=site)
-    return [torrent.to_dict() for torrent in torrents]
+    torrents = SearchChain().search_by_title(title=keyword, page=page,
+                                             sites=[int(site) for site in sites.split(",") if site] if sites else None,
+                                             cache_local=True)
+    if not torrents:
+        return schemas.Response(success=False, message="未搜索到任何资源")
+    return schemas.Response(success=True, data=[torrent.to_dict() for torrent in torrents])

app/api/endpoints/site.py

@@ -1,18 +1,26 @@
-from typing import List, Any
+from typing import List, Any, Dict, Optional
 
 from fastapi import APIRouter, Depends, HTTPException
 from sqlalchemy.orm import Session
 from starlette.background import BackgroundTasks
 
 from app import schemas
+from app.api.endpoints.plugin import register_plugin_api
 from app.chain.site import SiteChain
 from app.chain.torrents import TorrentsChain
+from app.command import Command
 from app.core.event import EventManager
+from app.core.plugin import PluginManager
 from app.core.security import verify_token
 from app.db import get_db
+from app.db.models import User
 from app.db.models.site import Site
 from app.db.models.siteicon import SiteIcon
+from app.db.models.sitestatistic import SiteStatistic
+from app.db.models.siteuserdata import SiteUserData
+from app.db.site_oper import SiteOper
 from app.db.systemconfig_oper import SystemConfigOper
+from app.db.user_oper import get_current_active_superuser
 from app.helper.sites import SitesHelper
 from app.scheduler import Scheduler
 from app.schemas.types import SystemConfigKey, EventType
@@ -23,7 +31,7 @@ router = APIRouter()
 
 @router.get("/", summary="所有站点", response_model=List[schemas.Site])
 def read_sites(db: Session = Depends(get_db),
-               _: schemas.TokenPayload = Depends(verify_token)) -> List[dict]:
+               _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> List[dict]:
     """
     获取站点列表
     """
@@ -35,25 +43,35 @@ def add_site(
         *,
         db: Session = Depends(get_db),
         site_in: schemas.Site,
-        _: schemas.TokenPayload = Depends(verify_token)
+        _: schemas.TokenPayload = Depends(get_current_active_superuser)
 ) -> Any:
     """
     新增站点
     """
     if not site_in.url:
         return schemas.Response(success=False, message="站点地址不能为空")
+    if SitesHelper().auth_level < 2:
+        return schemas.Response(success=False, message="用户未通过认证，无法使用站点功能！")
     domain = StringUtils.get_url_domain(site_in.url)
     site_info = SitesHelper().get_indexer(domain)
     if not site_info:
-        return schemas.Response(success=False, message="该站点不支持")
+        return schemas.Response(success=False, message="该站点不支持，请检查站点域名是否正确")
     if Site.get_by_domain(db, domain):
         return schemas.Response(success=False, message=f"{domain} 站点己存在")
     # 保存站点信息
     site_in.domain = domain
+    # 校正地址格式
+    _scheme, _netloc = StringUtils.get_url_netloc(site_in.url)
+    site_in.url = f"{_scheme}://{_netloc}/"
     site_in.name = site_info.get("name")
     site_in.id = None
+    site_in.public = 1 if site_info.get("public") else 0
     site = Site(**site_in.dict())
     site.create(db)
+    # 通知站点更新
+    EventManager().send_event(EventType.SiteUpdated, {
+        "domain": domain
+    })
     return schemas.Response(success=True)
 
 
@@ -62,7 +80,7 @@ def update_site(
         *,
         db: Session = Depends(get_db),
         site_in: schemas.Site,
-        _: schemas.TokenPayload = Depends(verify_token)
+        _: schemas.TokenPayload = Depends(get_current_active_superuser)
 ) -> Any:
     """
     更新站点信息
@@ -70,31 +88,20 @@ def update_site(
     site = Site.get(db, site_in.id)
     if not site:
         return schemas.Response(success=False, message="站点不存在")
+    # 校正地址格式
+    _scheme, _netloc = StringUtils.get_url_netloc(site_in.url)
+    site_in.url = f"{_scheme}://{_netloc}/"
     site.update(db, site_in.dict())
-    return schemas.Response(success=True)
-
-
-@router.delete("/{site_id}", summary="删除站点", response_model=schemas.Response)
-def delete_site(
-        site_id: int,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)
-) -> Any:
-    """
-    删除站点
-    """
-    Site.delete(db, site_id)
-    # 插件站点删除
-    EventManager().send_event(EventType.SiteDeleted,
-                              {
-                                  "site_id": site_id
-                              })
+    # 通知站点更新
+    EventManager().send_event(EventType.SiteUpdated, {
+        "domain": site_in.domain
+    })
     return schemas.Response(success=True)
 
 
 @router.get("/cookiecloud", summary="CookieCloud同步", response_model=schemas.Response)
 def cookie_cloud_sync(background_tasks: BackgroundTasks,
-                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+                      _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
     """
     运行CookieCloud同步站点信息
     """
@@ -103,8 +110,8 @@ def cookie_cloud_sync(background_tasks: BackgroundTasks,
 
 
 @router.get("/reset", summary="重置站点", response_model=schemas.Response)
-def cookie_cloud_sync(db: Session = Depends(get_db),
-                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def reset(db: Session = Depends(get_db),
+          _: User = Depends(get_current_active_superuser)) -> Any:
     """
     清空所有站点数据并重新同步CookieCloud站点信息
     """
@@ -116,18 +123,34 @@ def cookie_cloud_sync(db: Session = Depends(get_db),
     # 插件站点删除
     EventManager().send_event(EventType.SiteDeleted,
                               {
-                                  "site_id": None
+                                  "site_id": "*"
                               })
     return schemas.Response(success=True, message="站点已重置！")
 
 
+@router.post("/priorities", summary="批量更新站点优先级", response_model=schemas.Response)
+def update_sites_priority(
+        priorities: List[dict],
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    批量更新站点优先级
+    """
+    for priority in priorities:
+        site = Site.get(db, priority.get("id"))
+        if site:
+            site.update(db, {"pri": priority.get("pri")})
+    return schemas.Response(success=True)
+
+
 @router.get("/cookie/{site_id}", summary="更新站点Cookie&UA", response_model=schemas.Response)
 def update_cookie(
         site_id: int,
         username: str,
         password: str,
+        code: Optional[str] = None,
         db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+        _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
     """
     使用用户密码更新站点Cookie
     """
@@ -139,12 +162,68 @@ def update_cookie(
             detail=f"站点 {site_id} 不存在！",
         )
     # 更新Cookie
-    state, message = SiteChain(db).update_cookie(site_info=site_info,
-                                                 username=username,
-                                                 password=password)
+    state, message = SiteChain().update_cookie(site_info=site_info,
+                                               username=username,
+                                               password=password,
+                                               two_step_code=code)
     return schemas.Response(success=state, message=message)
 
 
+@router.post("/userdata/{site_id}", summary="更新站点用户数据", response_model=schemas.Response)
+def refresh_userdata(
+        site_id: int,
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    刷新站点用户数据
+    """
+    site = Site.get(db, site_id)
+    if not site:
+        raise HTTPException(
+            status_code=404,
+            detail=f"站点 {site_id} 不存在",
+        )
+    indexer = SitesHelper().get_indexer(site.domain)
+    if not indexer:
+        return schemas.Response(success=False, message="站点不支持索引或未通过用户认证！")
+    user_data = SiteChain().refresh_userdata(site=indexer) or {}
+    return schemas.Response(success=True, data=user_data)
+
+
+@router.get("/userdata/latest", summary="查询所有站点最新用户数据", response_model=List[schemas.SiteUserData])
+def read_userdata_latest(
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    查询所有站点最新用户数据
+    """
+    user_datas = SiteUserData.get_latest(db)
+    if not user_datas:
+        return []
+    return [user_data.to_dict() for user_data in user_datas]
+
+
+@router.get("/userdata/{site_id}", summary="查询某站点用户数据", response_model=schemas.Response)
+def read_userdata(
+        site_id: int,
+        workdate: Optional[str] = None,
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    查询站点用户数据
+    """
+    site = Site.get(db, site_id)
+    if not site:
+        raise HTTPException(
+            status_code=404,
+            detail=f"站点 {site_id} 不存在",
+        )
+    user_data = SiteUserData.get_by_domain(db, domain=site.domain, workdate=workdate)
+    if not user_data:
+        return schemas.Response(success=False, data=[])
+    return schemas.Response(success=True, data=user_data)
+
+
 @router.get("/test/{site_id}", summary="连接测试", response_model=schemas.Response)
 def test_site(site_id: int,
               db: Session = Depends(get_db),
@@ -158,7 +237,7 @@ def test_site(site_id: int,
             status_code=404,
             detail=f"站点 {site_id} 不存在",
         )
-    status, message = SiteChain(db).test(site.domain)
+    status, message = SiteChain().test(site.domain)
     return schemas.Response(success=status, message=message)
 
 
@@ -183,11 +262,44 @@ def site_icon(site_id: int,
     })
 
 
-@router.get("/resource/{site_id}", summary="站点资源", response_model=List[schemas.TorrentInfo])
-def site_resource(site_id: int,
+@router.get("/category/{site_id}", summary="站点分类", response_model=List[schemas.SiteCategory])
+def site_category(site_id: int,
                   db: Session = Depends(get_db),
                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
+    获取站点分类
+    """
+    site = Site.get(db, site_id)
+    if not site:
+        raise HTTPException(
+            status_code=404,
+            detail=f"站点 {site_id} 不存在",
+        )
+    indexer = SitesHelper().get_indexer(site.domain)
+    if not indexer:
+        raise HTTPException(
+            status_code=404,
+            detail=f"站点 {site.domain} 不支持",
+        )
+    category: Dict[str, List[dict]] = indexer.get('category') or []
+    if not category:
+        return []
+    result = []
+    for cats in category.values():
+        for cat in cats:
+            if cat not in result:
+                result.append(cat)
+    return result
+
+
+@router.get("/resource/{site_id}", summary="站点资源", response_model=List[schemas.TorrentInfo])
+def site_resource(site_id: int,
+                  keyword: Optional[str] = None,
+                  cat: Optional[str] = None,
+                  page: Optional[int] = 0,
+                  db: Session = Depends(get_db),
+                  _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
     浏览站点资源
     """
     site = Site.get(db, site_id)
@@ -196,7 +308,7 @@ def site_resource(site_id: int,
             status_code=404,
             detail=f"站点 {site_id} 不存在",
         )
-    torrents = TorrentsChain().browse(domain=site.domain)
+    torrents = TorrentsChain().browse(domain=site.domain, keyword=keyword, cat=cat, page=page)
     if not torrents:
         return []
     return [torrent.to_dict() for torrent in torrents]
@@ -221,28 +333,89 @@ def read_site_by_domain(
     return site
 
 
+@router.get("/statistic/{site_url}", summary="站点统计信息", response_model=schemas.SiteStatistic)
+def read_site_by_domain(
+        site_url: str,
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)
+) -> Any:
+    """
+    通过域名获取站点统计信息
+    """
+    domain = StringUtils.get_url_domain(site_url)
+    sitestatistic = SiteStatistic.get_by_domain(db, domain)
+    if sitestatistic:
+        return sitestatistic
+    return schemas.SiteStatistic(domain=domain)
+
+
 @router.get("/rss", summary="所有订阅站点", response_model=List[schemas.Site])
-def read_rss_sites(db: Session = Depends(get_db)) -> List[dict]:
+def read_rss_sites(db: Session = Depends(get_db),
+                   _: schemas.TokenPayload = Depends(verify_token)) -> List[dict]:
     """
     获取站点列表
     """
     # 选中的rss站点
     selected_sites = SystemConfigOper().get(SystemConfigKey.RssSites) or []
+
     # 所有站点
     all_site = Site.list_order_by_pri(db)
-    if not selected_sites or not all_site:
-        return []
+    if not selected_sites:
+        return all_site
 
     # 选中的rss站点
     rss_sites = [site for site in all_site if site and site.id in selected_sites]
     return rss_sites
 
 
+@router.get("/auth", summary="查询认证站点", response_model=dict)
+def read_auth_sites(_: schemas.TokenPayload = Depends(verify_token)) -> dict:
+    """
+    获取可认证站点列表
+    """
+    return SitesHelper().get_authsites()
+
+
+@router.post("/auth", summary="用户站点认证", response_model=schemas.Response)
+def auth_site(
+        auth_info: schemas.SiteAuth,
+        _: User = Depends(get_current_active_superuser)
+) -> Any:
+    """
+    用户站点认证
+    """
+    if not auth_info or not auth_info.site or not auth_info.params:
+        return schemas.Response(success=False, message="请输入认证站点和认证参数")
+    status, msg = SitesHelper().check_user(auth_info.site, auth_info.params)
+    SystemConfigOper().set(SystemConfigKey.UserSiteAuthParams, auth_info.dict())
+    # 认证成功后，重新初始化插件
+    PluginManager().init_config()
+    Scheduler().init_plugin_jobs()
+    Command().init_commands()
+    register_plugin_api()
+    return schemas.Response(success=status, message=msg)
+
+
+@router.get("/mapping", summary="获取站点域名到名称的映射", response_model=schemas.Response)
+def site_mapping(_: User = Depends(get_current_active_superuser)):
+    """
+    获取站点域名到名称的映射关系
+    """
+    try:
+        sites = SiteOper().list()
+        mapping = {}
+        for site in sites:
+            mapping[site.domain] = site.name
+        return schemas.Response(success=True, data=mapping)
+    except Exception as e:
+        return schemas.Response(success=False, message=f"获取映射失败：{str(e)}")
+
+
 @router.get("/{site_id}", summary="站点详情", response_model=schemas.Site)
 def read_site(
         site_id: int,
         db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)
+        _: schemas.TokenPayload = Depends(get_current_active_superuser)
 ) -> Any:
     """
     通过ID获取站点信息
@@ -254,3 +427,21 @@ def read_site(
             detail=f"站点 {site_id} 不存在",
         )
     return site
+
+
+@router.delete("/{site_id}", summary="删除站点", response_model=schemas.Response)
+def delete_site(
+        site_id: int,
+        db: Session = Depends(get_db),
+        _: User = Depends(get_current_active_superuser)
+) -> Any:
+    """
+    删除站点
+    """
+    Site.delete(db, site_id)
+    # 插件站点删除
+    EventManager().send_event(EventType.SiteDeleted,
+                              {
+                                  "site_id": site_id
+                              })
+    return schemas.Response(success=True)

app/api/endpoints/storage.py

@@ -0,0 +1,232 @@
+from datetime import datetime
+from pathlib import Path
+from typing import Any, List, Optional
+
+from fastapi import APIRouter, Depends, HTTPException
+from starlette.responses import FileResponse, Response
+
+from app import schemas
+from app.chain.storage import StorageChain
+from app.chain.transfer import TransferChain
+from app.core.config import settings
+from app.core.metainfo import MetaInfoPath
+from app.core.security import verify_token
+from app.db.models import User
+from app.db.user_oper import get_current_active_superuser
+from app.helper.progress import ProgressHelper
+from app.schemas.types import ProgressKey
+
+router = APIRouter()
+
+
+@router.get("/qrcode/{name}", summary="生成二维码内容", response_model=schemas.Response)
+def qrcode(name: str, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    生成二维码
+    """
+    qrcode_data, errmsg = StorageChain().generate_qrcode(name)
+    if qrcode_data:
+        return schemas.Response(success=True, data=qrcode_data, message=errmsg)
+    return schemas.Response(success=False, message=errmsg)
+
+
+@router.get("/check/{name}", summary="二维码登录确认", response_model=schemas.Response)
+def check(name: str, ck: Optional[str] = None, t: Optional[str] = None,
+          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    二维码登录确认
+    """
+    if ck or t:
+        data, errmsg = StorageChain().check_login(name, ck=ck, t=t)
+    else:
+        data, errmsg = StorageChain().check_login(name)
+    if data:
+        return schemas.Response(success=True, data=data)
+    return schemas.Response(success=False, message=errmsg)
+
+
+@router.post("/save/{name}", summary="保存存储配置", response_model=schemas.Response)
+def save(name: str,
+         conf: dict,
+         _: User = Depends(get_current_active_superuser)) -> Any:
+    """
+    保存存储配置
+    """
+    StorageChain().save_config(name, conf)
+    return schemas.Response(success=True)
+
+
+@router.get("/reset/{name}", summary="重置存储配置", response_model=schemas.Response)
+def reset(name: str,
+          _: User = Depends(get_current_active_superuser)) -> Any:
+    """
+    重置存储配置
+    """
+    StorageChain().reset_config(name)
+    return schemas.Response(success=True)
+
+
+@router.post("/list", summary="所有目录和文件", response_model=List[schemas.FileItem])
+def list_files(fileitem: schemas.FileItem,
+               sort: Optional[str] = 'updated_at',
+               _: User = Depends(get_current_active_superuser)) -> Any:
+    """
+    查询当前目录下所有目录和文件
+    :param fileitem: 文件项
+    :param sort: 排序方式，name:按名称排序，time:按修改时间排序
+    :param _: token
+    :return: 所有目录和文件
+    """
+    file_list = StorageChain().list_files(fileitem)
+    if file_list:
+        if sort == "name":
+            file_list.sort(key=lambda x: x.name or "")
+        else:
+            file_list.sort(key=lambda x: x.modify_time or datetime.min, reverse=True)
+    return file_list
+
+
+@router.post("/mkdir", summary="创建目录", response_model=schemas.Response)
+def mkdir(fileitem: schemas.FileItem,
+          name: str,
+          _: User = Depends(get_current_active_superuser)) -> Any:
+    """
+    创建目录
+    :param fileitem: 文件项
+    :param name: 目录名称
+    :param _: token
+    """
+    if not name:
+        return schemas.Response(success=False)
+    result = StorageChain().create_folder(fileitem, name)
+    if result:
+        return schemas.Response(success=True)
+    return schemas.Response(success=False)
+
+
+@router.post("/delete", summary="删除文件或目录", response_model=schemas.Response)
+def delete(fileitem: schemas.FileItem,
+           _: User = Depends(get_current_active_superuser)) -> Any:
+    """
+    删除文件或目录
+    :param fileitem: 文件项
+    :param _: token
+    """
+    result = StorageChain().delete_file(fileitem)
+    if result:
+        return schemas.Response(success=True)
+    return schemas.Response(success=False)
+
+
+@router.post("/download", summary="下载文件")
+def download(fileitem: schemas.FileItem,
+             _: User = Depends(get_current_active_superuser)) -> Any:
+    """
+    下载文件或目录
+    :param fileitem: 文件项
+    :param _: token
+    """
+    # 临时目录
+    tmp_file = StorageChain().download_file(fileitem)
+    if tmp_file:
+        return FileResponse(path=tmp_file)
+    return schemas.Response(success=False)
+
+
+@router.post("/image", summary="预览图片")
+def image(fileitem: schemas.FileItem,
+          _: User = Depends(get_current_active_superuser)) -> Any:
+    """
+    下载文件或目录
+    :param fileitem: 文件项
+    :param _: token
+    """
+    # 临时目录
+    tmp_file = StorageChain().download_file(fileitem)
+    if not tmp_file:
+        raise HTTPException(status_code=500, detail="图片读取出错")
+    return Response(content=tmp_file.read_bytes(), media_type="image/jpeg")
+
+
+@router.post("/rename", summary="重命名文件或目录", response_model=schemas.Response)
+def rename(fileitem: schemas.FileItem,
+           new_name: str,
+           recursive: Optional[bool] = False,
+           _: User = Depends(get_current_active_superuser)) -> Any:
+    """
+    重命名文件或目录
+    :param fileitem: 文件项
+    :param new_name: 新名称
+    :param recursive: 是否递归修改
+    :param _: token
+    """
+    if not new_name:
+        return schemas.Response(success=False, message="新名称为空")
+
+    # 重命名目录内文件
+    if recursive:
+        transferchain = TransferChain()
+        media_exts = settings.RMT_MEDIAEXT + settings.RMT_SUBEXT + settings.RMT_AUDIO_TRACK_EXT
+        # 递归修改目录内文件（智能识别命名）
+        sub_files: List[schemas.FileItem] = StorageChain().list_files(fileitem)
+        if sub_files:
+            # 开始进度
+            progress = ProgressHelper()
+            progress.start(ProgressKey.BatchRename)
+            total = len(sub_files)
+            handled = 0
+            for sub_file in sub_files:
+                handled += 1
+                progress.update(value=handled / total * 100,
+                                text=f"正在处理 {sub_file.name} ...",
+                                key=ProgressKey.BatchRename)
+                if sub_file.type == "dir":
+                    continue
+                if not sub_file.extension:
+                    continue
+                if f".{sub_file.extension.lower()}" not in media_exts:
+                    continue
+                sub_path = Path(f"{fileitem.path}{sub_file.name}")
+                meta = MetaInfoPath(sub_path)
+                mediainfo = transferchain.recognize_media(meta)
+                if not mediainfo:
+                    progress.end(ProgressKey.BatchRename)
+                    return schemas.Response(success=False, message=f"{sub_path.name} 未识别到媒体信息")
+                new_path = transferchain.recommend_name(meta=meta, mediainfo=mediainfo)
+                if not new_path:
+                    progress.end(ProgressKey.BatchRename)
+                    return schemas.Response(success=False, message=f"{sub_path.name} 未识别到新名称")
+                ret: schemas.Response = rename(fileitem=sub_file,
+                                               new_name=Path(new_path).name,
+                                               recursive=False)
+                if not ret.success:
+                    progress.end(ProgressKey.BatchRename)
+                    return schemas.Response(success=False, message=f"{sub_path.name} 重命名失败！")
+            progress.end(ProgressKey.BatchRename)
+    # 重命名自己
+    result = StorageChain().rename_file(fileitem, new_name)
+    if result:
+        return schemas.Response(success=True)
+    return schemas.Response(success=False)
+
+
+@router.get("/usage/{name}", summary="存储空间信息", response_model=schemas.StorageUsage)
+def usage(name: str, _: User = Depends(get_current_active_superuser)) -> Any:
+    """
+    查询存储空间
+    """
+    ret = StorageChain().storage_usage(name)
+    if ret:
+        return ret
+    return schemas.StorageUsage()
+
+
+@router.get("/transtype/{name}", summary="支持的整理方式获取", response_model=schemas.StorageTransType)
+def transtype(name: str, _: User = Depends(get_current_active_superuser)) -> Any:
+    """
+    查询支持的整理方式
+    """
+    ret = StorageChain().support_transtype(name)
+    if ret:
+        return schemas.StorageTransType(transtype=ret)
+    return schemas.StorageTransType()

app/api/endpoints/subscribe.py

@@ -1,53 +1,62 @@
-import json
-from typing import List, Any
+from typing import List, Any, Annotated, Optional
 
+import cn2an
 from fastapi import APIRouter, Request, BackgroundTasks, Depends, HTTPException, Header
 from sqlalchemy.orm import Session
 
 from app import schemas
 from app.chain.subscribe import SubscribeChain
 from app.core.config import settings
-from app.core.security import verify_token
+from app.core.context import MediaInfo
+from app.core.event import eventmanager
+from app.core.metainfo import MetaInfo
+from app.core.security import verify_token, verify_apitoken
 from app.db import get_db
 from app.db.models.subscribe import Subscribe
+from app.db.models.subscribehistory import SubscribeHistory
 from app.db.models.user import User
-from app.db.userauth import get_current_active_user
+from app.db.systemconfig_oper import SystemConfigOper
+from app.db.user_oper import get_current_active_user
+from app.helper.subscribe import SubscribeHelper
 from app.scheduler import Scheduler
-from app.schemas.types import MediaType
+from app.schemas.types import MediaType, EventType, SystemConfigKey
 
 router = APIRouter()
 
 
-def start_subscribe_add(db: Session, title: str, year: str,
+def start_subscribe_add(title: str, year: str,
                         mtype: MediaType, tmdbid: int, season: int, username: str):
     """
     启动订阅任务
     """
-    SubscribeChain(db).add(title=title, year=year,
-                           mtype=mtype, tmdbid=tmdbid, season=season, username=username)
+    SubscribeChain().add(title=title, year=year,
+                         mtype=mtype, tmdbid=tmdbid, season=season, username=username)
 
 
-@router.get("/", summary="所有订阅", response_model=List[schemas.Subscribe])
+@router.get("/", summary="查询所有订阅", response_model=List[schemas.Subscribe])
 def read_subscribes(
         db: Session = Depends(get_db),
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询所有订阅
     """
-    subscribes = Subscribe.list(db)
-    for subscribe in subscribes:
-        if subscribe.sites:
-            subscribe.sites = json.loads(subscribe.sites)
-    return subscribes
+    return Subscribe.list(db)
+
+
+@router.get("/list", summary="查询所有订阅（API_TOKEN）", response_model=List[schemas.Subscribe])
+def list_subscribes(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    查询所有订阅 API_TOKEN认证（?token=xxx）
+    """
+    return read_subscribes()
 
 
 @router.post("/", summary="新增订阅", response_model=schemas.Response)
 def create_subscribe(
         *,
         subscribe_in: schemas.Subscribe,
-        db: Session = Depends(get_db),
         current_user: User = Depends(get_current_active_user),
-) -> Any:
+) -> schemas.Response:
     """
     新增订阅
     """
@@ -56,23 +65,25 @@ def create_subscribe(
         mtype = MediaType(subscribe_in.type)
     else:
         mtype = None
+    # 豆瓣标理
+    if subscribe_in.doubanid or subscribe_in.bangumiid:
+        meta = MetaInfo(subscribe_in.name)
+        subscribe_in.name = meta.name
+        subscribe_in.season = meta.begin_season
     # 标题转换
     if subscribe_in.name:
         title = subscribe_in.name
     else:
         title = None
-    sid, message = SubscribeChain(db).add(mtype=mtype,
-                                          title=title,
-                                          year=subscribe_in.year,
-                                          tmdbid=subscribe_in.tmdbid,
-                                          season=subscribe_in.season,
-                                          doubanid=subscribe_in.doubanid,
-                                          username=current_user.name,
-                                          best_version=subscribe_in.best_version,
-                                          exist_ok=True)
-    return schemas.Response(success=True if sid else False, message=message, data={
-        "id": sid
-    })
+    # 订阅用户
+    subscribe_in.username = current_user.name
+    sid, message = SubscribeChain().add(mtype=mtype,
+                                        title=title,
+                                        exist_ok=True,
+                                        **subscribe_in.dict())
+    return schemas.Response(
+        success=bool(sid), message=message, data={"id": sid}
+    )
 
 
 @router.put("/", summary="更新订阅", response_model=schemas.Response)
@@ -88,9 +99,8 @@ def update_subscribe(
     subscribe = Subscribe.get(db, subscribe_in.id)
     if not subscribe:
         return schemas.Response(success=False, message="订阅不存在")
-    if subscribe_in.sites is not None:
-        subscribe_in.sites = json.dumps(subscribe_in.sites)
     # 避免更新缺失集数
+    old_subscribe_dict = subscribe.to_dict()
     subscribe_dict = subscribe_in.dict()
     if not subscribe_in.lack_episode:
         # 没有缺失集数时，缺失集数清空，避免更新为0
@@ -101,33 +111,87 @@ def update_subscribe(
             subscribe_dict["lack_episode"] = (subscribe.lack_episode
                                               + (subscribe_in.total_episode
                                                  - (subscribe.total_episode or 0)))
+    # 是否手动修改过总集数
+    if subscribe_in.total_episode != subscribe.total_episode:
+        subscribe_dict["manual_total_episode"] = 1
     subscribe.update(db, subscribe_dict)
+    # 发送订阅调整事件
+    eventmanager.send_event(EventType.SubscribeModified, {
+        "subscribe_id": subscribe.id,
+        "old_subscribe_info": old_subscribe_dict,
+        "subscribe_info": subscribe.to_dict(),
+    })
+    return schemas.Response(success=True)
+
+
+@router.put("/status/{subid}", summary="更新订阅状态", response_model=schemas.Response)
+def update_subscribe_status(
+        subid: int,
+        state: str,
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    更新订阅状态
+    """
+    subscribe = Subscribe.get(db, subid)
+    if not subscribe:
+        return schemas.Response(success=False, message="订阅不存在")
+    valid_states = ["R", "P", "S"]
+    if state not in valid_states:
+        return schemas.Response(success=False, message="无效的订阅状态")
+    old_subscribe_dict = subscribe.to_dict()
+    subscribe.update(db, {
+        "state": state
+    })
+    # 发送订阅调整事件
+    eventmanager.send_event(EventType.SubscribeModified, {
+        "subscribe_id": subscribe.id,
+        "old_subscribe_info": old_subscribe_dict,
+        "subscribe_info": subscribe.to_dict(),
+    })
     return schemas.Response(success=True)
 
 
 @router.get("/media/{mediaid}", summary="查询订阅", response_model=schemas.Subscribe)
 def subscribe_mediaid(
         mediaid: str,
-        season: int = None,
+        season: Optional[int] = None,
+        title: Optional[str] = None,
         db: Session = Depends(get_db),
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    根据TMDBID或豆瓣ID查询订阅 tmdb:/douban:
+    根据 TMDBID/豆瓣ID/BangumiId 查询订阅 tmdb:/douban:
     """
+    title_check = False
     if mediaid.startswith("tmdb:"):
         tmdbid = mediaid[5:]
         if not tmdbid or not str(tmdbid).isdigit():
             return Subscribe()
-        result = Subscribe.exists(db, int(tmdbid), season)
+        result = Subscribe.exists(db, tmdbid=int(tmdbid), season=season)
     elif mediaid.startswith("douban:"):
         doubanid = mediaid[7:]
         if not doubanid:
             return Subscribe()
         result = Subscribe.get_by_doubanid(db, doubanid)
+        if not result and title:
+            title_check = True
+    elif mediaid.startswith("bangumi:"):
+        bangumiid = mediaid[8:]
+        if not bangumiid or not str(bangumiid).isdigit():
+            return Subscribe()
+        result = Subscribe.get_by_bangumiid(db, int(bangumiid))
+        if not result and title:
+            title_check = True
     else:
-        result = None
-    if result and result.sites:
-        result.sites = json.loads(result.sites)
+        result = Subscribe.get_by_mediaid(db, mediaid)
+        if not result and title:
+            title_check = True
+    # 使用名称检查订阅
+    if title_check and title:
+        meta = MetaInfo(title)
+        if season:
+            meta.begin_season = season
+        result = Subscribe.get_by_title(db, title=meta.name, season=meta.begin_season)
 
     return result if result else Subscribe()
 
@@ -142,6 +206,32 @@ def refresh_subscribes(
     return schemas.Response(success=True)
 
 
+@router.get("/reset/{subid}", summary="重置订阅", response_model=schemas.Response)
+def reset_subscribes(
+        subid: int,
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    重置订阅
+    """
+    subscribe = Subscribe.get(db, subid)
+    if subscribe:
+        old_subscribe_dict = subscribe.to_dict()
+        subscribe.update(db, {
+            "note": [],
+            "lack_episode": subscribe.total_episode,
+            "state": "R"
+        })
+        # 发送订阅调整事件
+        eventmanager.send_event(EventType.SubscribeModified, {
+            "subscribe_id": subscribe.id,
+            "old_subscribe_info": old_subscribe_dict,
+            "subscribe_info": subscribe.to_dict(),
+        })
+        return schemas.Response(success=True)
+    return schemas.Response(success=False, message="订阅不存在")
+
+
 @router.get("/check", summary="刷新订阅 TMDB 信息", response_model=schemas.Response)
 def check_subscribes(
         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
@@ -162,9 +252,11 @@ def search_subscribes(
     background_tasks.add_task(
         Scheduler().start,
         job_id="subscribe_search",
-        sid=None,
-        state='R',
-        manual=True
+        **{
+            "sid": None,
+            "state": 'R',
+            "manual": True
+        }
     )
     return schemas.Response(success=True)
 
@@ -180,70 +272,58 @@ def search_subscribe(
     background_tasks.add_task(
         Scheduler().start,
         job_id="subscribe_search",
-        sid=subscribe_id,
-        state=None,
-        manual=True
+        **{
+            "sid": subscribe_id,
+            "state": None,
+            "manual": True
+        }
     )
     return schemas.Response(success=True)
 
 
-@router.get("/{subscribe_id}", summary="订阅详情", response_model=schemas.Subscribe)
-def read_subscribe(
-        subscribe_id: int,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    根据订阅编号查询订阅信息
-    """
-    subscribe = Subscribe.get(db, subscribe_id)
-    if subscribe.sites:
-        subscribe.sites = json.loads(subscribe.sites)
-    return subscribe
-
-
 @router.delete("/media/{mediaid}", summary="删除订阅", response_model=schemas.Response)
 def delete_subscribe_by_mediaid(
         mediaid: str,
-        season: int = None,
+        season: Optional[int] = None,
         db: Session = Depends(get_db),
         _: schemas.TokenPayload = Depends(verify_token)
 ) -> Any:
     """
     根据TMDBID或豆瓣ID删除订阅 tmdb:/douban:
     """
+    delete_subscribes = []
     if mediaid.startswith("tmdb:"):
         tmdbid = mediaid[5:]
         if not tmdbid or not str(tmdbid).isdigit():
             return schemas.Response(success=False)
-        Subscribe().delete_by_tmdbid(db, int(tmdbid), season)
+        subscribes = Subscribe().get_by_tmdbid(db, int(tmdbid), season)
+        delete_subscribes.extend(subscribes)
     elif mediaid.startswith("douban:"):
         doubanid = mediaid[7:]
         if not doubanid:
             return schemas.Response(success=False)
-        Subscribe().delete_by_doubanid(db, doubanid)
-
-    return schemas.Response(success=True)
-
-
-@router.delete("/{subscribe_id}", summary="删除订阅", response_model=schemas.Response)
-def delete_subscribe(
-        subscribe_id: int,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)
-) -> Any:
-    """
-    删除订阅信息
-    """
-    Subscribe.delete(db, subscribe_id)
+        subscribe = Subscribe().get_by_doubanid(db, doubanid)
+        if subscribe:
+            delete_subscribes.append(subscribe)
+    else:
+        subscribe = Subscribe().get_by_mediaid(db, mediaid)
+        if subscribe:
+            delete_subscribes.append(subscribe)
+    for subscribe in delete_subscribes:
+        Subscribe().delete(db, subscribe.id)
+        # 发送事件
+        eventmanager.send_event(EventType.SubscribeDeleted, {
+            "subscribe_id": subscribe.id,
+            "subscribe_info": subscribe.to_dict()
+        })
     return schemas.Response(success=True)
 
 
 @router.post("/seerr", summary="OverSeerr/JellySeerr通知订阅", response_model=schemas.Response)
 async def seerr_subscribe(request: Request, background_tasks: BackgroundTasks,
-                          db: Session = Depends(get_db),
-                          authorization: str = Header(None)) -> Any:
+                          authorization: Annotated[str | None, Header()] = None) -> Any:
     """
-    Jellyseerr/Overseerr订阅
+    Jellyseerr/Overseerr网络勾子通知订阅
     """
     if not authorization or authorization != settings.API_TOKEN:
         raise HTTPException(
@@ -268,7 +348,6 @@ async def seerr_subscribe(request: Request, background_tasks: BackgroundTasks,
     # 添加订阅
     if media_type == MediaType.MOVIE:
         background_tasks.add_task(start_subscribe_add,
-                                  db=db,
                                   mtype=media_type,
                                   tmdbid=tmdbId,
                                   title=subject,
@@ -283,7 +362,6 @@ async def seerr_subscribe(request: Request, background_tasks: BackgroundTasks,
                 break
         for season in seasons:
             background_tasks.add_task(start_subscribe_add,
-                                      db=db,
                                       mtype=media_type,
                                       tmdbid=tmdbId,
                                       title=subject,
@@ -292,3 +370,229 @@ async def seerr_subscribe(request: Request, background_tasks: BackgroundTasks,
                                       username=user_name)
 
     return schemas.Response(success=True)
+
+
+@router.get("/history/{mtype}", summary="查询订阅历史", response_model=List[schemas.Subscribe])
+def subscribe_history(
+        mtype: str,
+        page: Optional[int] = 1,
+        count: Optional[int] = 30,
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询电影/电视剧订阅历史
+    """
+    return SubscribeHistory.list_by_type(db, mtype=mtype, page=page, count=count)
+
+
+@router.delete("/history/{history_id}", summary="删除订阅历史", response_model=schemas.Response)
+def delete_subscribe(
+        history_id: int,
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)
+) -> Any:
+    """
+    删除订阅历史
+    """
+    SubscribeHistory.delete(db, history_id)
+    return schemas.Response(success=True)
+
+
+@router.get("/popular", summary="热门订阅（基于用户共享数据）", response_model=List[schemas.MediaInfo])
+def popular_subscribes(
+        stype: str,
+        page: Optional[int] = 1,
+        count: Optional[int] = 30,
+        min_sub: Optional[int] = None,
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询热门订阅
+    """
+    subscribes = SubscribeHelper().get_statistic(stype=stype, page=page, count=count)
+    if subscribes:
+        ret_medias = []
+        for sub in subscribes:
+            # 订阅人数
+            count = sub.get("count")
+            if min_sub and count < min_sub:
+                continue
+            media = MediaInfo()
+            media.type = MediaType(sub.get("type"))
+            media.tmdb_id = sub.get("tmdbid")
+            # 处理标题
+            title = sub.get("name")
+            season = sub.get("season")
+            if season and int(season) > 1 and media.tmdb_id:
+                # 小写数据转大写
+                season_str = cn2an.an2cn(season, "low")
+                title = f"{title} 第{season_str}季"
+            media.title = title
+            media.year = sub.get("year")
+            media.douban_id = sub.get("doubanid")
+            media.bangumi_id = sub.get("bangumiid")
+            media.tvdb_id = sub.get("tvdbid")
+            media.imdb_id = sub.get("imdbid")
+            media.season = sub.get("season")
+            media.overview = sub.get("description")
+            media.vote_average = sub.get("vote")
+            media.poster_path = sub.get("poster")
+            media.backdrop_path = sub.get("backdrop")
+            media.popularity = count
+            ret_medias.append(media)
+        return [media.to_dict() for media in ret_medias]
+    return []
+
+
+@router.get("/user/{username}", summary="用户订阅", response_model=List[schemas.Subscribe])
+def user_subscribes(
+        username: str,
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询用户订阅
+    """
+    return Subscribe.list_by_username(db, username)
+
+
+@router.get("/files/{subscribe_id}", summary="订阅相关文件信息", response_model=schemas.SubscrbieInfo)
+def subscribe_files(
+        subscribe_id: int,
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    订阅相关文件信息
+    """
+    subscribe = Subscribe.get(db, subscribe_id)
+    if subscribe:
+        return SubscribeChain().subscribe_files_info(subscribe)
+    return schemas.SubscrbieInfo()
+
+
+@router.post("/share", summary="分享订阅", response_model=schemas.Response)
+def subscribe_share(
+        sub: schemas.SubscribeShare,
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    分享订阅
+    """
+    state, errmsg = SubscribeHelper().sub_share(subscribe_id=sub.subscribe_id,
+                                                share_title=sub.share_title,
+                                                share_comment=sub.share_comment,
+                                                share_user=sub.share_user)
+    return schemas.Response(success=state, message=errmsg)
+
+
+@router.delete("/share/{share_id}", summary="删除分享", response_model=schemas.Response)
+def subscribe_share_delete(
+        share_id: int,
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    删除分享
+    """
+    state, errmsg = SubscribeHelper().share_delete(share_id=share_id)
+    return schemas.Response(success=state, message=errmsg)
+
+
+@router.post("/fork", summary="复用订阅", response_model=schemas.Response)
+def subscribe_fork(
+        sub: schemas.SubscribeShare,
+        current_user: User = Depends(get_current_active_user)) -> Any:
+    """
+    复用订阅
+    """
+    sub_dict = sub.dict()
+    sub_dict.pop("id")
+    for key in list(sub_dict.keys()):
+        if not hasattr(schemas.Subscribe(), key):
+            sub_dict.pop(key)
+    result = create_subscribe(subscribe_in=schemas.Subscribe(**sub_dict),
+                              current_user=current_user)
+    if result.success:
+        SubscribeHelper().sub_fork(share_id=sub.id)
+    return result
+
+
+@router.get("/follow", summary="查询已Follow的订阅分享人", response_model=List[str])
+def followed_subscribers(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询已Follow的订阅分享人
+    """
+    return SystemConfigOper().get(SystemConfigKey.FollowSubscribers) or []
+
+
+@router.post("/follow", summary="Follow订阅分享人", response_model=schemas.Response)
+def follow_subscriber(
+        share_uid: Optional[str] = None,
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    Follow订阅分享人
+    """
+    subscribers = SystemConfigOper().get(SystemConfigKey.FollowSubscribers) or []
+    if share_uid and share_uid not in subscribers:
+        subscribers.append(share_uid)
+        SystemConfigOper().set(SystemConfigKey.FollowSubscribers, subscribers)
+    return schemas.Response(success=True)
+
+
+@router.delete("/follow", summary="取消Follow订阅分享人", response_model=schemas.Response)
+def unfollow_subscriber(
+        share_uid: Optional[str] = None,
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    取消Follow订阅分享人
+    """
+    subscribers = SystemConfigOper().get(SystemConfigKey.FollowSubscribers) or []
+    if share_uid and share_uid in subscribers:
+        subscribers.remove(share_uid)
+        SystemConfigOper().set(SystemConfigKey.FollowSubscribers, subscribers)
+    return schemas.Response(success=True)
+
+
+@router.get("/shares", summary="查询分享的订阅", response_model=List[schemas.SubscribeShare])
+def popular_subscribes(
+        name: Optional[str] = None,
+        page: Optional[int] = 1,
+        count: Optional[int] = 30,
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询分享的订阅
+    """
+    return SubscribeHelper().get_shares(name=name, page=page, count=count)
+
+
+@router.get("/{subscribe_id}", summary="订阅详情", response_model=schemas.Subscribe)
+def read_subscribe(
+        subscribe_id: int,
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据订阅编号查询订阅信息
+    """
+    if not subscribe_id:
+        return Subscribe()
+    return Subscribe.get(db, subscribe_id)
+
+
+@router.delete("/{subscribe_id}", summary="删除订阅", response_model=schemas.Response)
+def delete_subscribe(
+        subscribe_id: int,
+        db: Session = Depends(get_db),
+        _: schemas.TokenPayload = Depends(verify_token)
+) -> Any:
+    """
+    删除订阅信息
+    """
+    subscribe = Subscribe.get(db, subscribe_id)
+    if subscribe:
+        subscribe.delete(db, subscribe_id)
+        # 发送事件
+        eventmanager.send_event(EventType.SubscribeDeleted, {
+            "subscribe_id": subscribe_id,
+            "subscribe_info": subscribe.to_dict()
+        })
+        # 统计订阅
+        SubscribeHelper().sub_done_async({
+            "tmdbid": subscribe.tmdbid,
+            "doubanid": subscribe.doubanid
+        })
+    return schemas.Response(success=True)

app/api/endpoints/system.py

@@ -1,160 +1,406 @@
+import asyncio
+import io
 import json
-import time
+import re
+import tempfile
+from collections import deque
 from datetime import datetime
-from typing import Union
+from pathlib import Path
+from typing import Optional, Union, Annotated
 
-import tailer
-from fastapi import APIRouter, HTTPException, Depends
+import aiofiles
+import pillow_avif  # noqa 用于自动注册AVIF支持
+from PIL import Image
+from fastapi import APIRouter, Body, Depends, HTTPException, Header, Request, Response
 from fastapi.responses import StreamingResponse
-from sqlalchemy.orm import Session
 
 from app import schemas
 from app.chain.search import SearchChain
-from app.core.config import settings
-from app.core.security import verify_token
-from app.db import get_db
+from app.chain.system import SystemChain
+from app.core.config import global_vars, settings
+from app.core.metainfo import MetaInfo
+from app.core.module import ModuleManager
+from app.core.security import verify_apitoken, verify_resource_token, verify_token
+from app.core.event import eventmanager
+from app.db.models import User
 from app.db.systemconfig_oper import SystemConfigOper
+from app.db.user_oper import get_current_active_superuser
+from app.helper.mediaserver import MediaServerHelper
 from app.helper.message import MessageHelper
 from app.helper.progress import ProgressHelper
+from app.helper.rule import RuleHelper
+from app.helper.sites import SitesHelper
+from app.helper.subscribe import SubscribeHelper
+from app.helper.system import SystemHelper
+from app.log import logger
 from app.scheduler import Scheduler
-from app.schemas.types import SystemConfigKey
+from app.schemas import ConfigChangeEventData
+from app.schemas.types import SystemConfigKey, EventType
+from app.utils.crypto import HashUtils
 from app.utils.http import RequestUtils
-from app.utils.system import SystemUtils
+from app.utils.security import SecurityUtils
+from app.utils.url import UrlUtils
 from version import APP_VERSION
 
 router = APIRouter()
 
 
-@router.get("/env", summary="查询系统环境变量", response_model=schemas.Response)
-def get_env_setting(_: schemas.TokenPayload = Depends(verify_token)):
+def fetch_image(
+        url: str,
+        proxy: bool = False,
+        use_disk_cache: bool = False,
+        if_none_match: Optional[str] = None,
+        allowed_domains: Optional[set[str]] = None) -> Response:
     """
-    查询系统环境变量，包括当前版本号
+    处理图片缓存逻辑，支持HTTP缓存和磁盘缓存
     """
-    info = settings.dict(
-        exclude={"SECRET_KEY", "SUPERUSER_PASSWORD", "API_TOKEN"}
+    if not url:
+        raise HTTPException(status_code=404, detail="URL not provided")
+
+    if allowed_domains is None:
+        allowed_domains = set(settings.SECURITY_IMAGE_DOMAINS)
+
+    # 验证URL安全性
+    if not SecurityUtils.is_safe_url(url, allowed_domains):
+        raise HTTPException(status_code=404, detail="Unsafe URL")
+
+    # 后续观察系统性能表现，如果发现磁盘缓存和HTTP缓存无法满足高并发情况下的响应速度需求，可以考虑重新引入内存缓存
+    cache_path = None
+    if use_disk_cache:
+        # 生成缓存路径
+        sanitized_path = SecurityUtils.sanitize_url_path(url)
+        cache_path = settings.CACHE_PATH / "images" / sanitized_path
+
+        # 没有文件类型，则添加后缀，在恶意文件类型和实际需求下的折衷选择
+        if not cache_path.suffix:
+            cache_path = cache_path.with_suffix(".jpg")
+
+        # 确保缓存路径和文件类型合法
+        if not SecurityUtils.is_safe_path(settings.CACHE_PATH, cache_path, settings.SECURITY_IMAGE_SUFFIXES):
+            raise HTTPException(status_code=400, detail="Invalid cache path or file type")
+
+        # 目前暂不考虑磁盘缓存文件是否过期，后续通过缓存清理机制处理
+        if cache_path.exists():
+            try:
+                content = cache_path.read_bytes()
+                etag = HashUtils.md5(content)
+                headers = RequestUtils.generate_cache_headers(etag, max_age=86400 * 7)
+                if if_none_match == etag:
+                    return Response(status_code=304, headers=headers)
+                return Response(content=content, media_type="image/jpeg", headers=headers)
+            except Exception as e:
+                # 如果读取磁盘缓存发生异常，这里仅记录日志，尝试再次请求远端进行处理
+                logger.debug(f"Failed to read cache file {cache_path}: {e}")
+
+    # 请求远程图片
+    referer = "https://movie.douban.com/" if "doubanio.com" in url else None
+    proxies = settings.PROXY if proxy else None
+    response = RequestUtils(ua=settings.USER_AGENT, proxies=proxies, referer=referer,
+                            accept_type="image/avif,image/webp,image/apng,*/*").get_res(url=url)
+    if not response:
+        raise HTTPException(status_code=502, detail="Failed to fetch the image from the remote server")
+
+    # 验证下载的内容是否为有效图片
+    try:
+        Image.open(io.BytesIO(response.content)).verify()
+    except Exception as e:
+        logger.debug(f"Invalid image format for URL {url}: {e}")
+        raise HTTPException(status_code=502, detail="Invalid image format")
+
+    content = response.content
+    response_headers = response.headers
+
+    cache_control_header = response_headers.get("Cache-Control", "")
+    cache_directive, max_age = RequestUtils.parse_cache_control(cache_control_header)
+
+    # 如果需要使用磁盘缓存，则保存到磁盘
+    if use_disk_cache and cache_path:
+        try:
+            if not cache_path.parent.exists():
+                cache_path.parent.mkdir(parents=True, exist_ok=True)
+            with tempfile.NamedTemporaryFile(dir=cache_path.parent, delete=False) as tmp_file:
+                tmp_file.write(content)
+                temp_path = Path(tmp_file.name)
+            temp_path.replace(cache_path)
+        except Exception as e:
+            logger.debug(f"Failed to write cache file {cache_path}: {e}")
+
+    # 检查 If-None-Match
+    etag = HashUtils.md5(content)
+    if if_none_match == etag:
+        headers = RequestUtils.generate_cache_headers(etag, cache_directive, max_age)
+        return Response(status_code=304, headers=headers)
+
+    headers = RequestUtils.generate_cache_headers(etag, cache_directive, max_age)
+
+    return Response(
+        content=content,
+        media_type=response_headers.get("Content-Type") or UrlUtils.get_mime_type(url, "image/jpeg"),
+        headers=headers
     )
+
+
+@router.get("/img/{proxy}", summary="图片代理")
+def proxy_img(
+        imgurl: str,
+        proxy: bool = False,
+        if_none_match: Annotated[str | None, Header()] = None,
+        _: schemas.TokenPayload = Depends(verify_resource_token)
+) -> Response:
+    """
+    图片代理，可选是否使用代理服务器，支持 HTTP 缓存
+    """
+    # 媒体服务器添加图片代理支持
+    hosts = [config.config.get("host") for config in MediaServerHelper().get_configs().values() if
+             config and config.config and config.config.get("host")]
+    allowed_domains = set(settings.SECURITY_IMAGE_DOMAINS) | set(hosts)
+    return fetch_image(url=imgurl, proxy=proxy, use_disk_cache=False,
+                       if_none_match=if_none_match, allowed_domains=allowed_domains)
+
+
+@router.get("/cache/image", summary="图片缓存")
+def cache_img(
+        url: str,
+        if_none_match: Annotated[str | None, Header()] = None,
+        _: schemas.TokenPayload = Depends(verify_resource_token)
+) -> Response:
+    """
+    本地缓存图片文件，支持 HTTP 缓存，如果启用全局图片缓存，则使用磁盘缓存
+    """
+    # 如果没有启用全局图片缓存，则不使用磁盘缓存
+    proxy = "doubanio.com" not in url
+    return fetch_image(url=url, proxy=proxy, use_disk_cache=settings.GLOBAL_IMAGE_CACHE, if_none_match=if_none_match)
+
+
+@router.get("/global", summary="查询非敏感系统设置", response_model=schemas.Response)
+def get_global_setting(token: str):
+    """
+    查询非敏感系统设置（默认鉴权）
+    """
+    if token != "moviepilot":
+        raise HTTPException(status_code=403, detail="Forbidden")
+
+    # FIXME: 新增敏感配置项时要在此处添加排除项
+    info = settings.dict(
+        exclude={"SECRET_KEY", "RESOURCE_SECRET_KEY", "API_TOKEN", "TMDB_API_KEY", "TVDB_API_KEY", "FANART_API_KEY",
+                 "COOKIECLOUD_KEY", "COOKIECLOUD_PASSWORD", "GITHUB_TOKEN", "REPO_GITHUB_TOKEN"}
+    )
+    # 追加用户唯一ID和订阅分享管理权限
     info.update({
-        "VERSION": APP_VERSION
+        "USER_UNIQUE_ID": SubscribeHelper().get_user_uuid(),
+        "SUBSCRIBE_SHARE_MANAGE": SubscribeHelper().is_admin_user(),
     })
     return schemas.Response(success=True,
                             data=info)
 
 
+@router.get("/env", summary="查询系统配置", response_model=schemas.Response)
+def get_env_setting(_: User = Depends(get_current_active_superuser)):
+    """
+    查询系统环境变量，包括当前版本号（仅管理员）
+    """
+    info = settings.dict(
+        exclude={"SECRET_KEY", "RESOURCE_SECRET_KEY"}
+    )
+    info.update({
+        "VERSION": APP_VERSION,
+        "AUTH_VERSION": SitesHelper().auth_version,
+        "INDEXER_VERSION": SitesHelper().indexer_version,
+        "FRONTEND_VERSION": SystemChain().get_frontend_version()
+    })
+    return schemas.Response(success=True,
+                            data=info)
+
+
+@router.post("/env", summary="更新系统配置", response_model=schemas.Response)
+def set_env_setting(env: dict,
+                    _: User = Depends(get_current_active_superuser)):
+    """
+    更新系统环境变量（仅管理员）
+    """
+    result = settings.update_settings(env=env)
+    # 统计成功和失败的结果
+    success_updates = {k: v for k, v in result.items() if v[0]}
+    failed_updates = {k: v for k, v in result.items() if v[0] is False}
+
+    if failed_updates:
+        return schemas.Response(
+            success=False,
+            message=f"{', '.join([v[1] for v in failed_updates.values()])}",
+            data={
+                "success_updates": success_updates,
+                "failed_updates": failed_updates
+            }
+        )
+
+    if success_updates:
+        for key in success_updates.keys():
+            # 发送配置变更事件
+            eventmanager.send_event(etype=EventType.ConfigChanged, data=ConfigChangeEventData(
+                key=key,
+                value=getattr(settings, key, None),
+                change_type="update"
+            ))
+
+    return schemas.Response(
+        success=True,
+        message="所有配置项更新成功",
+        data={
+            "success_updates": success_updates
+        }
+    )
+
+
 @router.get("/progress/{process_type}", summary="实时进度")
-def get_progress(process_type: str, token: str):
+async def get_progress(request: Request, process_type: str, _: schemas.TokenPayload = Depends(verify_resource_token)):
     """
     实时获取处理进度，返回格式为SSE
     """
-    if not token or not verify_token(token):
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
-
     progress = ProgressHelper()
 
-    def event_generator():
-        while True:
-            detail = progress.get(process_type)
-            yield 'data: %s\n\n' % json.dumps(detail)
-            time.sleep(0.2)
+    async def event_generator():
+        try:
+            while not global_vars.is_system_stopped:
+                if await request.is_disconnected():
+                    break
+                detail = progress.get(process_type)
+                yield f"data: {json.dumps(detail)}\n\n"
+                await asyncio.sleep(0.2)
+        except asyncio.CancelledError:
+            return
 
     return StreamingResponse(event_generator(), media_type="text/event-stream")
 
 
 @router.get("/setting/{key}", summary="查询系统设置", response_model=schemas.Response)
 def get_setting(key: str,
-                _: schemas.TokenPayload = Depends(verify_token)):
+                _: User = Depends(get_current_active_superuser)):
     """
-    查询系统设置
+    查询系统设置（仅管理员）
     """
+    if hasattr(settings, key):
+        value = getattr(settings, key)
+    else:
+        value = SystemConfigOper().get(key)
     return schemas.Response(success=True, data={
-        "value": SystemConfigOper().get(key)
+        "value": value
     })
 
 
 @router.post("/setting/{key}", summary="更新系统设置", response_model=schemas.Response)
-def set_setting(key: str, value: Union[list, dict, str, int] = None,
-                _: schemas.TokenPayload = Depends(verify_token)):
+def set_setting(
+    key: str,
+    value: Annotated[Union[list, dict, bool, int, str] | None, Body()] = None,
+    _: User = Depends(get_current_active_superuser),
+):
     """
-    更新系统设置
+    更新系统设置（仅管理员）
     """
-    SystemConfigOper().set(key, value)
-    return schemas.Response(success=True)
+    if hasattr(settings, key):
+        success, message = settings.update_setting(key=key, value=value)
+        if success:
+            # 发送配置变更事件
+            eventmanager.send_event(etype=EventType.ConfigChanged, data=ConfigChangeEventData(
+                key=key,
+                value=value,
+                change_type="update"
+            ))
+        elif success is None:
+            success = True
+        return schemas.Response(success=success, message=message)
+    elif key in {item.value for item in SystemConfigKey}:
+        if isinstance(value, list):
+            value = list(filter(None, value))
+            value = value if value else None
+        success = SystemConfigOper().set(key, value)
+        if success:
+            # 发送配置变更事件
+            eventmanager.send_event(etype=EventType.ConfigChanged, data=ConfigChangeEventData(
+                key=key,
+                value=value,
+                change_type="update"
+            ))
+        return schemas.Response(success=True)
+    else:
+        return schemas.Response(success=False, message=f"配置项 '{key}' 不存在")
 
 
 @router.get("/message", summary="实时消息")
-def get_message(token: str):
+async def get_message(request: Request, role: Optional[str] = "system",
+                      _: schemas.TokenPayload = Depends(verify_resource_token)):
     """
     实时获取系统消息，返回格式为SSE
     """
-    if not token or not verify_token(token):
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
-
     message = MessageHelper()
 
-    def event_generator():
-        while True:
-            detail = message.get()
-            yield 'data: %s\n\n' % (detail or '')
-            time.sleep(3)
+    async def event_generator():
+        try:
+            while not global_vars.is_system_stopped:
+                if await request.is_disconnected():
+                    break
+                detail = message.get(role)
+                yield f"data: {detail or ''}\n\n"
+                await asyncio.sleep(3)
+        except asyncio.CancelledError:
+            return
 
     return StreamingResponse(event_generator(), media_type="text/event-stream")
 
 
 @router.get("/logging", summary="实时日志")
-def get_logging(token: str):
+async def get_logging(request: Request, length: Optional[int] = 50, logfile: Optional[str] = "moviepilot.log",
+                      _: schemas.TokenPayload = Depends(verify_resource_token)):
     """
-    实时获取系统日志，返回格式为SSE
+    实时获取系统日志
+    length = -1 时, 返回text/plain
+    否则 返回格式SSE
     """
-    if not token or not verify_token(token):
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
+    log_path = settings.LOG_PATH / logfile
 
-    def log_generator():
-        log_path = settings.LOG_PATH / 'moviepilot.log'
-        # 读取文件末尾50行，不使用tailer模块
-        with open(log_path, 'r', encoding='utf-8') as f:
-            for line in f.readlines()[-50:]:
-                yield 'data: %s\n\n' % line
-        while True:
-            for text in tailer.follow(open(log_path, 'r', encoding='utf-8')):
-                yield 'data: %s\n\n' % (text or '')
-            time.sleep(1)
+    if not SecurityUtils.is_safe_path(settings.LOG_PATH, log_path, allowed_suffixes={".log"}):
+        raise HTTPException(status_code=404, detail="Not Found")
 
-    return StreamingResponse(log_generator(), media_type="text/event-stream")
+    if not log_path.exists() or not log_path.is_file():
+        raise HTTPException(status_code=404, detail="Not Found")
 
+    async def log_generator():
+        try:
+            # 使用固定大小的双向队列来限制内存使用
+            lines_queue = deque(maxlen=max(length, 50))
+            # 使用 aiofiles 异步读取文件
+            async with aiofiles.open(log_path, mode="r", encoding="utf-8") as f:
+                # 逐行读取文件，将每一行存入队列
+                file_content = await f.read()
+                for line in file_content.splitlines():
+                    lines_queue.append(line)
+                for line in lines_queue:
+                    yield f"data: {line}\n\n"
+                # 移动文件指针到文件末尾，继续监听新增内容
+                await f.seek(0, 2)
+                while not global_vars.is_system_stopped:
+                    if await request.is_disconnected():
+                        break
+                    line = await f.readline()
+                    if not line:
+                        await asyncio.sleep(0.5)
+                        continue
+                    yield f"data: {line}\n\n"
+        except asyncio.CancelledError:
+            return
 
-@router.get("/nettest", summary="测试网络连通性")
-def nettest(url: str,
-            proxy: bool,
-            _: schemas.TokenPayload = Depends(verify_token)):
-    """
-    测试网络连通性
-    """
-    # 记录开始的毫秒数
-    start_time = datetime.now()
-    url = url.replace("{TMDBAPIKEY}", settings.TMDB_API_KEY)
-    result = RequestUtils(proxies=settings.PROXY if proxy else None,
-                          ua=settings.USER_AGENT).get_res(url)
-    # 计时结束的毫秒数
-    end_time = datetime.now()
-    # 计算相关秒数
-    if result and result.status_code == 200:
-        return schemas.Response(success=True, data={
-            "time": round((end_time - start_time).microseconds / 1000)
-        })
-    elif result:
-        return schemas.Response(success=False, message=f"错误码：{result.status_code}", data={
-            "time": round((end_time - start_time).microseconds / 1000)
-        })
+    # 根据length参数返回不同的响应
+    if length == -1:
+        # 返回全部日志作为文本响应
+        if not log_path.exists():
+            return Response(content="日志文件不存在！", media_type="text/plain")
+        with open(log_path, "r", encoding='utf-8') as file:
+            text = file.read()
+        # 倒序输出
+        text = "\n".join(text.split("\n")[::-1])
+        return Response(content=text, media_type="text/plain")
     else:
-        return schemas.Response(success=False, message="网络连接失败！")
+        # 返回SSE流响应
+        return StreamingResponse(log_generator(), media_type="text/event-stream")
 
 
 @router.get("/versions", summary="查询Github所有Release版本", response_model=schemas.Response)
@@ -162,7 +408,8 @@ def latest_version(_: schemas.TokenPayload = Depends(verify_token)):
     """
     查询Github所有Release版本
     """
-    version_res = RequestUtils().get_res(f"https://api.github.com/repos/jxxghp/MoviePilot/releases")
+    version_res = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS).get_res(
+        f"https://api.github.com/repos/jxxghp/MoviePilot/releases")
     if version_res:
         ver_json = version_res.json()
         if ver_json:
@@ -170,11 +417,10 @@ def latest_version(_: schemas.TokenPayload = Depends(verify_token)):
     return schemas.Response(success=False)
 
 
-@router.get("/ruletest", summary="优先级规则测试", response_model=schemas.Response)
+@router.get("/ruletest", summary="过滤规则测试", response_model=schemas.Response)
 def ruletest(title: str,
-             subtitle: str = None,
-             ruletype: str = None,
-             db: Session = Depends(get_db),
+             rulegroup_name: str,
+             subtitle: Optional[str] = None,
              _: schemas.TokenPayload = Depends(verify_token)):
     """
     过滤规则测试，规则类型 1-订阅，2-洗版，3-搜索
@@ -183,47 +429,135 @@ def ruletest(title: str,
         title=title,
         description=subtitle,
     )
-    if ruletype == "2":
-        rule_string = SystemConfigOper().get(SystemConfigKey.BestVersionFilterRules)
-    elif ruletype == "3":
-        rule_string = SystemConfigOper().get(SystemConfigKey.SearchFilterRules)
-    else:
-        rule_string = SystemConfigOper().get(SystemConfigKey.SubscribeFilterRules)
-    if not rule_string:
-        return schemas.Response(success=False, message="优先级规则未设置！")
+    # 查询规则组详情
+    rulegroup = RuleHelper().get_rule_group(rulegroup_name)
+    if not rulegroup:
+        return schemas.Response(success=False, message=f"过滤规则组 {rulegroup_name} 不存在！")
+
+    # 根据标题查询媒体信息
+    media_info = SearchChain().recognize_media(MetaInfo(title=title, subtitle=subtitle))
+    if not media_info:
+        return schemas.Response(success=False, message="未识别到媒体信息！")
 
     # 过滤
-    result = SearchChain(db).filter_torrents(rule_string=rule_string,
-                                             torrent_list=[torrent])
+    result = SearchChain().filter_torrents(rule_groups=[rulegroup.name],
+                                           torrent_list=[torrent], mediainfo=media_info)
     if not result:
-        return schemas.Response(success=False, message="不符合优先级规则！")
+        return schemas.Response(success=False, message="不符合过滤规则！")
     return schemas.Response(success=True, data={
         "priority": 100 - result[0].pri_order + 1
     })
 
 
+@router.get("/nettest", summary="测试网络连通性")
+def nettest(
+    url: str,
+    proxy: bool,
+    include: Optional[str] = None,
+    _: schemas.TokenPayload = Depends(verify_token),
+):
+    """
+    测试网络连通性
+    """
+    # 记录开始的毫秒数
+    start_time = datetime.now()
+    headers = None
+    if "github" in url or "{GITHUB_PROXY}" in url:
+        # 这是github的连通性测试
+        url = url.replace(
+            "{GITHUB_PROXY}", UrlUtils.standardize_base_url(settings.GITHUB_PROXY or "")
+        )
+        headers = settings.GITHUB_HEADERS
+    url = url.replace("{TMDBAPIKEY}", settings.TMDB_API_KEY)
+    url = url.replace(
+        "{PIP_PROXY}",
+        UrlUtils.standardize_base_url(settings.PIP_PROXY or "https://pypi.org/simple/"),
+    )
+    result = RequestUtils(
+        proxies=settings.PROXY if proxy else None,
+        headers=headers,
+        timeout=10,
+        ua=settings.USER_AGENT,
+    ).get_res(url)
+    # 计时结束的毫秒数
+    end_time = datetime.now()
+    time = round((end_time - start_time).total_seconds() * 1000)
+    # 计算相关秒数
+    if result is None:
+        return schemas.Response(success=False, message="无法连接", data={"time": time})
+    elif result.status_code == 200:
+        if include and not re.search(r"%s" % include, result.text, re.IGNORECASE):
+            # 通常是被加速代理跳转到其它页面了
+            logger.error(f"{url} 的响应内容不匹配包含规则 {include}")
+            return schemas.Response(
+                success=False,
+                message=f"无效响应，不匹配 {include}",
+                data={"time": time},
+            )
+        return schemas.Response(success=True, data={"time": time})
+    else:
+        return schemas.Response(
+            success=False, message=f"错误码：{result.status_code}", data={"time": time}
+        )
+
+
+@router.get("/modulelist", summary="查询已加载的模块ID列表", response_model=schemas.Response)
+def modulelist(_: schemas.TokenPayload = Depends(verify_token)):
+    """
+    查询已加载的模块ID列表
+    """
+    modules = [{
+        "id": k,
+        "name": v.get_name(),
+    } for k, v in ModuleManager().get_modules().items()]
+    return schemas.Response(success=True, data={
+        "modules": modules
+    })
+
+
+@router.get("/moduletest/{moduleid}", summary="模块可用性测试", response_model=schemas.Response)
+def moduletest(moduleid: str, _: schemas.TokenPayload = Depends(verify_token)):
+    """
+    模块可用性测试接口
+    """
+    state, errmsg = ModuleManager().test(moduleid)
+    return schemas.Response(success=state, message=errmsg)
+
+
 @router.get("/restart", summary="重启系统", response_model=schemas.Response)
-def restart_system(_: schemas.TokenPayload = Depends(verify_token)):
+def restart_system(_: User = Depends(get_current_active_superuser)):
     """
-    重启系统
+    重启系统（仅管理员）
     """
-    if not SystemUtils.can_restart():
+    if not SystemHelper.can_restart():
         return schemas.Response(success=False, message="当前运行环境不支持重启操作！")
+    # 标识停止事件
+    global_vars.stop_system()
     # 执行重启
-    ret, msg = SystemUtils.restart()
+    ret, msg = SystemHelper.restart()
     return schemas.Response(success=ret, message=msg)
 
 
 @router.get("/runscheduler", summary="运行服务", response_model=schemas.Response)
-def execute_command(jobid: str,
-                    _: schemas.TokenPayload = Depends(verify_token)):
+def run_scheduler(jobid: str,
+                  _: User = Depends(get_current_active_superuser)):
     """
-    执行命令
+    执行命令（仅管理员）
     """
     if not jobid:
         return schemas.Response(success=False, message="命令不能为空！")
-    if jobid == "subscribe_search":
-        Scheduler().start(jobid, state = 'R')
-    else:
-        Scheduler().start(jobid)
-    return schemas.Response(success=True)
+    Scheduler().start(jobid)
+    return schemas.Response(success=True)
+
+
+@router.get("/runscheduler2", summary="运行服务（API_TOKEN）", response_model=schemas.Response)
+def run_scheduler2(jobid: str,
+                   _: Annotated[str, Depends(verify_apitoken)]):
+    """
+    执行命令（API_TOKEN认证）
+    """
+    if not jobid:
+        return schemas.Response(success=False, message="命令不能为空！")
+
+    Scheduler().start(jobid)
+    return schemas.Response(success=True)

app/api/endpoints/tmdb.py

@@ -1,186 +1,122 @@
-from typing import List, Any
+from typing import List, Any, Optional
 
 from fastapi import APIRouter, Depends
-from sqlalchemy.orm import Session
 
 from app import schemas
 from app.chain.tmdb import TmdbChain
-from app.core.context import MediaInfo
 from app.core.security import verify_token
-from app.db import get_db
 from app.schemas.types import MediaType
 
 router = APIRouter()
 
 
 @router.get("/seasons/{tmdbid}", summary="TMDB所有季", response_model=List[schemas.TmdbSeason])
-def tmdb_seasons(tmdbid: int, db: Session = Depends(get_db),
-                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+def tmdb_seasons(tmdbid: int, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据TMDBID查询themoviedb所有季信息
     """
-    seasons_info = TmdbChain(db).tmdb_seasons(tmdbid=tmdbid)
-    if not seasons_info:
-        return []
-    else:
+    seasons_info = TmdbChain().tmdb_seasons(tmdbid=tmdbid)
+    if seasons_info:
         return seasons_info
+    return []
 
 
 @router.get("/similar/{tmdbid}/{type_name}", summary="类似电影/电视剧", response_model=List[schemas.MediaInfo])
 def tmdb_similar(tmdbid: int,
                  type_name: str,
-                 db: Session = Depends(get_db),
                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据TMDBID查询类似电影/电视剧，type_name: 电影/电视剧
     """
     mediatype = MediaType(type_name)
     if mediatype == MediaType.MOVIE:
-        tmdbinfos = TmdbChain(db).movie_similar(tmdbid=tmdbid)
+        medias = TmdbChain().movie_similar(tmdbid=tmdbid)
     elif mediatype == MediaType.TV:
-        tmdbinfos = TmdbChain(db).tv_similar(tmdbid=tmdbid)
+        medias = TmdbChain().tv_similar(tmdbid=tmdbid)
     else:
         return []
-    if not tmdbinfos:
-        return []
-    else:
-        return [MediaInfo(tmdb_info=tmdbinfo).to_dict() for tmdbinfo in tmdbinfos]
+    if medias:
+        return [media.to_dict() for media in medias]
+    return []
 
 
 @router.get("/recommend/{tmdbid}/{type_name}", summary="推荐电影/电视剧", response_model=List[schemas.MediaInfo])
 def tmdb_recommend(tmdbid: int,
                    type_name: str,
-                   db: Session = Depends(get_db),
                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据TMDBID查询推荐电影/电视剧，type_name: 电影/电视剧
     """
     mediatype = MediaType(type_name)
     if mediatype == MediaType.MOVIE:
-        tmdbinfos = TmdbChain(db).movie_recommend(tmdbid=tmdbid)
+        medias = TmdbChain().movie_recommend(tmdbid=tmdbid)
     elif mediatype == MediaType.TV:
-        tmdbinfos = TmdbChain(db).tv_recommend(tmdbid=tmdbid)
+        medias = TmdbChain().tv_recommend(tmdbid=tmdbid)
     else:
         return []
-    if not tmdbinfos:
-        return []
-    else:
-        return [MediaInfo(tmdb_info=tmdbinfo).to_dict() for tmdbinfo in tmdbinfos]
+    if medias:
+        return [media.to_dict() for media in medias]
+    return []
 
 
-@router.get("/credits/{tmdbid}/{type_name}", summary="演员阵容", response_model=List[schemas.TmdbPerson])
+@router.get("/collection/{collection_id}", summary="系列合集详情", response_model=List[schemas.MediaInfo])
+def tmdb_collection(collection_id: int,
+                    page: Optional[int] = 1,
+                    count: Optional[int] = 20,
+                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据合集ID查询合集详情
+    """
+    medias = TmdbChain().tmdb_collection(collection_id=collection_id)
+    if medias:
+        return [media.to_dict() for media in medias][(page - 1) * count:page * count]
+    return []
+
+
+@router.get("/credits/{tmdbid}/{type_name}", summary="演员阵容", response_model=List[schemas.MediaPerson])
 def tmdb_credits(tmdbid: int,
                  type_name: str,
-                 page: int = 1,
-                 db: Session = Depends(get_db),
+                 page: Optional[int] = 1,
                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据TMDBID查询演员阵容，type_name: 电影/电视剧
     """
     mediatype = MediaType(type_name)
     if mediatype == MediaType.MOVIE:
-        tmdbinfos = TmdbChain(db).movie_credits(tmdbid=tmdbid, page=page)
+        persons = TmdbChain().movie_credits(tmdbid=tmdbid, page=page)
     elif mediatype == MediaType.TV:
-        tmdbinfos = TmdbChain(db).tv_credits(tmdbid=tmdbid, page=page)
+        persons = TmdbChain().tv_credits(tmdbid=tmdbid, page=page)
     else:
         return []
-    if not tmdbinfos:
-        return []
-    else:
-        return [schemas.TmdbPerson(**tmdbinfo) for tmdbinfo in tmdbinfos]
+    return persons or []
 
 
-@router.get("/person/{person_id}", summary="人物详情", response_model=schemas.TmdbPerson)
+@router.get("/person/{person_id}", summary="人物详情", response_model=schemas.MediaPerson)
 def tmdb_person(person_id: int,
-                db: Session = Depends(get_db),
                 _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据人物ID查询人物详情
     """
-    tmdbinfo = TmdbChain(db).person_detail(person_id=person_id)
-    if not tmdbinfo:
-        return schemas.TmdbPerson()
-    else:
-        return schemas.TmdbPerson(**tmdbinfo)
+    return TmdbChain().person_detail(person_id=person_id)
 
 
 @router.get("/person/credits/{person_id}", summary="人物参演作品", response_model=List[schemas.MediaInfo])
 def tmdb_person_credits(person_id: int,
-                        page: int = 1,
-                        db: Session = Depends(get_db),
+                        page: Optional[int] = 1,
                         _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据人物ID查询人物参演作品
     """
-    tmdbinfo = TmdbChain(db).person_credits(person_id=person_id, page=page)
-    if not tmdbinfo:
-        return []
-    else:
-        return [MediaInfo(tmdb_info=tmdbinfo).to_dict() for tmdbinfo in tmdbinfo]
-
-
-@router.get("/movies", summary="TMDB电影", response_model=List[schemas.MediaInfo])
-def tmdb_movies(sort_by: str = "popularity.desc",
-                with_genres: str = "",
-                with_original_language: str = "",
-                page: int = 1,
-                db: Session = Depends(get_db),
-                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览TMDB电影信息
-    """
-    movies = TmdbChain(db).tmdb_discover(mtype=MediaType.MOVIE,
-                                         sort_by=sort_by,
-                                         with_genres=with_genres,
-                                         with_original_language=with_original_language,
-                                         page=page)
-    if not movies:
-        return []
-    return [MediaInfo(tmdb_info=movie).to_dict() for movie in movies]
-
-
-@router.get("/tvs", summary="TMDB剧集", response_model=List[schemas.MediaInfo])
-def tmdb_tvs(sort_by: str = "popularity.desc",
-             with_genres: str = "",
-             with_original_language: str = "",
-             page: int = 1,
-             db: Session = Depends(get_db),
-             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览TMDB剧集信息
-    """
-    tvs = TmdbChain(db).tmdb_discover(mtype=MediaType.TV,
-                                      sort_by=sort_by,
-                                      with_genres=with_genres,
-                                      with_original_language=with_original_language,
-                                      page=page)
-    if not tvs:
-        return []
-    return [MediaInfo(tmdb_info=tv).to_dict() for tv in tvs]
-
-
-@router.get("/trending", summary="TMDB流行趋势", response_model=List[schemas.MediaInfo])
-def tmdb_trending(page: int = 1,
-                  db: Session = Depends(get_db),
-                  _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    浏览TMDB剧集信息
-    """
-    infos = TmdbChain(db).tmdb_trending(page=page)
-    if not infos:
-        return []
-    return [MediaInfo(tmdb_info=info).to_dict() for info in infos]
+    medias = TmdbChain().person_credits(person_id=person_id, page=page)
+    if medias:
+        return [media.to_dict() for media in medias]
+    return []
 
 
 @router.get("/{tmdbid}/{season}", summary="TMDB季所有集", response_model=List[schemas.TmdbEpisode])
-def tmdb_season_episodes(tmdbid: int, season: int,
-                         db: Session = Depends(get_db),
+def tmdb_season_episodes(tmdbid: int, season: int, episode_group: Optional[str] = None,
                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     根据TMDBID查询某季的所有信信息
     """
-    episodes_info = TmdbChain(db).tmdb_episodes(tmdbid=tmdbid, season=season)
-    if not episodes_info:
-        return []
-    else:
-        return episodes_info
+    return TmdbChain().tmdb_episodes(tmdbid=tmdbid, season=season, episode_group=episode_group)

app/api/endpoints/torrent.py

@@ -0,0 +1,199 @@
+from typing import Optional
+
+from fastapi import APIRouter, Depends
+
+from app import schemas
+from app.chain.media import MediaChain
+from app.chain.torrents import TorrentsChain
+from app.core.config import settings
+from app.core.context import MediaInfo
+from app.core.metainfo import MetaInfo
+from app.db.models import User
+from app.db.user_oper import get_current_active_superuser
+from app.utils.crypto import HashUtils
+
+router = APIRouter()
+
+
+@router.get("/cache", summary="获取种子缓存", response_model=schemas.Response)
+def torrents_cache(_: User = Depends(get_current_active_superuser)):
+    """
+    获取当前种子缓存数据
+    """
+    torrents_chain = TorrentsChain()
+
+    # 获取spider和rss两种缓存
+    if settings.SUBSCRIBE_MODE == "rss":
+        cache_info = torrents_chain.get_torrents("rss")
+    else:
+        cache_info = torrents_chain.get_torrents("spider")
+
+    # 统计信息
+    torrent_count = sum(len(torrents) for torrents in cache_info.values())
+
+    # 转换为前端需要的格式
+    torrent_data = []
+    for domain, contexts in cache_info.items():
+        for context in contexts:
+            torrent_hash = HashUtils.md5(f"{context.torrent_info.title}{context.torrent_info.description}")
+            torrent_data.append({
+                "hash": torrent_hash,
+                "domain": domain,
+                "title": context.torrent_info.title,
+                "description": context.torrent_info.description,
+                "size": context.torrent_info.size,
+                "pubdate": context.torrent_info.pubdate,
+                "site_name": context.torrent_info.site_name,
+                "media_name": context.media_info.title if context.media_info else "",
+                "media_year": context.media_info.year if context.media_info else "",
+                "media_type": context.media_info.type if context.media_info else "",
+                "season_episode": context.meta_info.season_episode if context.meta_info else "",
+                "resource_term": context.meta_info.resource_term if context.meta_info else "",
+                "enclosure": context.torrent_info.enclosure,
+                "page_url": context.torrent_info.page_url,
+                "poster_path": context.media_info.get_poster_image() if context.media_info else "",
+                "backdrop_path": context.media_info.get_backdrop_image() if context.media_info else ""
+            })
+
+    return schemas.Response(success=True, data={
+        "count": torrent_count,
+        "sites": len(cache_info),
+        "data": torrent_data
+    })
+
+
+@router.delete("/cache/{domain}/{torrent_hash}", summary="删除指定种子缓存",
+               response_model=schemas.Response)
+def delete_cache(domain: str, torrent_hash: str, _: User = Depends(get_current_active_superuser)):
+    """
+    删除指定的种子缓存
+    :param domain: 站点域名
+    :param torrent_hash: 种子hash（使用title+description的md5）
+    :param _: 当前用户，必须是超级用户
+    """
+
+    torrents_chain = TorrentsChain()
+
+    try:
+        # 获取当前缓存
+        cache_data = torrents_chain.get_torrents()
+
+        if domain not in cache_data:
+            return schemas.Response(success=False, message=f"站点 {domain} 缓存不存在")
+
+        # 查找并删除指定种子
+        original_count = len(cache_data[domain])
+        cache_data[domain] = [
+            context for context in cache_data[domain]
+            if HashUtils.md5(f"{context.torrent_info.title}{context.torrent_info.description}") != torrent_hash
+        ]
+
+        if len(cache_data[domain]) == original_count:
+            return schemas.Response(success=False, message="未找到指定的种子")
+
+        # 保存更新后的缓存
+        torrents_chain.save_cache(cache_data, torrents_chain.cache_file)
+
+        return schemas.Response(success=True, message="种子删除成功")
+    except Exception as e:
+        return schemas.Response(success=False, message=f"删除失败：{str(e)}")
+
+
+@router.delete("/cache", summary="清理种子缓存", response_model=schemas.Response)
+def clear_cache(_: User = Depends(get_current_active_superuser)):
+    """
+    清理所有种子缓存
+    """
+    torrents_chain = TorrentsChain()
+
+    try:
+        torrents_chain.clear_torrents()
+        return schemas.Response(success=True, message="种子缓存清理完成")
+    except Exception as e:
+        return schemas.Response(success=False, message=f"清理失败：{str(e)}")
+
+
+@router.post("/cache/refresh", summary="刷新种子缓存", response_model=schemas.Response)
+def refresh_cache(_: User = Depends(get_current_active_superuser)):
+    """
+    刷新种子缓存
+    """
+    from app.chain.torrents import TorrentsChain
+
+    torrents_chain = TorrentsChain()
+
+    try:
+        result = torrents_chain.refresh()
+
+        # 统计刷新结果
+        total_count = sum(len(torrents) for torrents in result.values())
+        sites_count = len(result)
+
+        return schemas.Response(success=True, message=f"缓存刷新完成，共刷新 {sites_count} 个站点，{total_count} 个种子")
+    except Exception as e:
+        return schemas.Response(success=False, message=f"刷新失败：{str(e)}")
+
+
+@router.post("/cache/reidentify/{domain}/{torrent_hash}", summary="重新识别种子", response_model=schemas.Response)
+def reidentify_cache(domain: str, torrent_hash: str,
+                     tmdbid: Optional[int] = None, doubanid: Optional[str] = None,
+                     _: User = Depends(get_current_active_superuser)):
+    """
+    重新识别指定的种子
+    :param domain: 站点域名
+    :param torrent_hash: 种子hash（使用title+description的md5）
+    :param tmdbid: 手动指定的TMDB ID
+    :param doubanid: 手动指定的豆瓣ID
+    :param _: 当前用户，必须是超级用户
+    """
+
+    torrents_chain = TorrentsChain()
+    media_chain = MediaChain()
+
+    try:
+        # 获取当前缓存
+        cache_data = torrents_chain.get_torrents()
+
+        if domain not in cache_data:
+            return schemas.Response(success=False, message=f"站点 {domain} 缓存不存在")
+
+        # 查找指定种子
+        target_context = None
+        for context in cache_data[domain]:
+            if HashUtils.md5(f"{context.torrent_info.title}{context.torrent_info.description}") == torrent_hash:
+                target_context = context
+                break
+
+        if not target_context:
+            return schemas.Response(success=False, message="未找到指定的种子")
+
+        # 重新识别
+        meta = MetaInfo(title=target_context.torrent_info.title,
+                        subtitle=target_context.torrent_info.description)
+        if tmdbid or doubanid:
+            # 手动指定媒体信息
+            mediainfo = MediaChain().recognize_media(meta=meta, tmdbid=tmdbid, doubanid=doubanid)
+        else:
+            # 自动重新识别
+            mediainfo = media_chain.recognize_by_meta(meta)
+
+        if not mediainfo:
+            # 创建空的媒体信息
+            mediainfo = MediaInfo()
+        else:
+            # 清理多余数据
+            mediainfo.clear()
+
+        # 更新上下文中的媒体信息
+        target_context.media_info = mediainfo
+
+        # 保存更新后的缓存
+        torrents_chain.save_cache(cache_data, TorrentsChain().cache_file)
+
+        return schemas.Response(success=True, message="重新识别完成", data={
+            "media_name": mediainfo.title if mediainfo else "",
+            "media_year": mediainfo.year if mediainfo else "",
+            "media_type": mediainfo.type.value if mediainfo and mediainfo.type else ""
+        })
+    except Exception as e:
+        return schemas.Response(success=False, message=f"重新识别失败：{str(e)}")

app/api/endpoints/transfer.py

@@ -1,74 +1,160 @@
 from pathlib import Path
-from typing import Any
+from typing import Any, List, Annotated, Optional
 
 from fastapi import APIRouter, Depends
 from sqlalchemy.orm import Session
 
 from app import schemas
+from app.chain.media import MediaChain
+from app.chain.storage import StorageChain
 from app.chain.transfer import TransferChain
-from app.core.security import verify_token
+from app.core.metainfo import MetaInfoPath
+from app.core.security import verify_token, verify_apitoken
 from app.db import get_db
-from app.schemas import MediaType
+from app.db.models.transferhistory import TransferHistory
+from app.db.user_oper import get_current_active_superuser
+from app.schemas import MediaType, FileItem, ManualTransferItem
 
 router = APIRouter()
 
 
-@router.post("/manual", summary="手动转移", response_model=schemas.Response)
-def manual_transfer(path: str,
-                    target: str = None,
-                    tmdbid: int = None,
-                    type_name: str = None,
-                    season: int = None,
-                    transfer_type: str = None,
-                    episode_format: str = None,
-                    episode_detail: str = None,
-                    episode_part: str = None,
-                    episode_offset: int = 0,
-                    min_filesize: int = 0,
-                    db: Session = Depends(get_db),
-                    _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+@router.get("/name", summary="查询整理后的名称", response_model=schemas.Response)
+def query_name(path: str, filetype: str,
+               _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    手动转移，支持自定义剧集识别格式
-    :param path: 转移路径或文件
-    :param target: 目标路径
-    :param type_name: 媒体类型、电影/电视剧
-    :param tmdbid: tmdbid
-    :param season: 剧集季号
-    :param transfer_type: 转移类型，move/copy
-    :param episode_format: 剧集识别格式
-    :param episode_detail: 剧集识别详细信息
-    :param episode_part: 剧集识别分集信息
-    :param episode_offset: 剧集识别偏移量
-    :param min_filesize: 最小文件大小(MB)
+    查询整理后的名称
+    :param path: 文件路径
+    :param filetype: 文件类型
+    :param _: Token校验
+    """
+    meta = MetaInfoPath(Path(path))
+    mediainfo = MediaChain().recognize_media(meta)
+    if not mediainfo:
+        return schemas.Response(success=False, message="未识别到媒体信息")
+    new_path = TransferChain().recommend_name(meta=meta, mediainfo=mediainfo)
+    if not new_path:
+        return schemas.Response(success=False, message="未识别到新名称")
+    if filetype == "dir":
+        parents = Path(new_path).parents
+        if len(parents) > 2:
+            new_name = parents[1].name
+        else:
+            new_name = parents[0].name
+    else:
+        new_name = Path(new_path).name
+    return schemas.Response(success=True, data={
+        "name": new_name
+    })
+
+
+@router.get("/queue", summary="查询整理队列", response_model=List[schemas.TransferJob])
+def query_queue(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询整理队列
+    :param _: Token校验
+    """
+    return TransferChain().get_queue_tasks()
+
+
+@router.delete("/queue", summary="从整理队列中删除任务", response_model=schemas.Response)
+def remove_queue(fileitem: schemas.FileItem, _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    查询整理队列
+    :param fileitem: 文件项
+    :param _: Token校验
+    """
+    TransferChain().remove_from_queue(fileitem)
+    return schemas.Response(success=True)
+
+
+@router.post("/manual", summary="手动转移", response_model=schemas.Response)
+def manual_transfer(transer_item: ManualTransferItem,
+                    background: Optional[bool] = False,
+                    db: Session = Depends(get_db),
+                    _: schemas.TokenPayload = Depends(get_current_active_superuser)) -> Any:
+    """
+    手动转移，文件或历史记录，支持自定义剧集识别格式
+    :param transer_item: 手工整理项
+    :param background: 后台运行
     :param db: 数据库
     :param _: Token校验
     """
-    in_path = Path(path)
-    if target:
-        target = Path(target)
-        if not target.exists():
-            return schemas.Response(success=False, message=f"目标路径不存在")
+    force = False
+    target_path = Path(transer_item.target_path) if transer_item.target_path else None
+    if transer_item.logid:
+        # 查询历史记录
+        history: TransferHistory = TransferHistory.get(db, transer_item.logid)
+        if not history:
+            return schemas.Response(success=False, message=f"整理记录不存在，ID：{transer_item.logid}")
+        # 强制转移
+        force = True
+        if history.status and ("move" in history.mode):
+            # 重新整理成功的转移，则使用成功的 dest 做 in_path
+            src_fileitem = FileItem(**history.dest_fileitem)
+        else:
+            # 源路径
+            src_fileitem = FileItem(**history.src_fileitem)
+            # 目的路径
+            if history.dest_fileitem:
+                # 删除旧的已整理文件
+                dest_fileitem = FileItem(**history.dest_fileitem)
+                state = StorageChain().delete_media_file(dest_fileitem, mtype=MediaType(history.type))
+                if not state:
+                    return schemas.Response(success=False, message=f"{dest_fileitem.path} 删除失败")
+
+        # 从历史数据获取信息
+        if transer_item.from_history:
+            transer_item.type_name = history.type if history.type else transer_item.type_name
+            transer_item.tmdbid = int(history.tmdbid) if history.tmdbid else transer_item.tmdbid
+            transer_item.doubanid = str(history.doubanid) if history.doubanid else transer_item.doubanid
+            transer_item.season = int(str(history.seasons).replace("S", "")) if history.seasons else transer_item.season
+            if history.episodes:
+                if "-" in str(history.episodes):
+                    # E01-E03多集合并
+                    episode_start, episode_end = str(history.episodes).split("-")
+                    episode_list: list[int] = []
+                    for i in range(int(episode_start.replace("E", "")), int(episode_end.replace("E", "")) + 1):
+                        episode_list.append(i)
+                    transer_item.episode_detail = ",".join(str(e) for e in episode_list)
+                else:
+                    # E01单集
+                    transer_item.episode_detail = str(history.episodes).replace("E", "")
+
+    elif transer_item.fileitem:
+        src_fileitem = transer_item.fileitem
+    else:
+        return schemas.Response(success=False, message=f"缺少参数")
+
     # 类型
-    mtype = MediaType(type_name) if type_name else None
+    mtype = MediaType(transer_item.type_name) if transer_item.type_name else None
     # 自定义格式
     epformat = None
-    if episode_offset or episode_part or episode_detail or episode_format:
+    if transer_item.episode_offset or transer_item.episode_part \
+            or transer_item.episode_detail or transer_item.episode_format:
         epformat = schemas.EpisodeFormat(
-            format=episode_format,
-            detail=episode_detail,
-            part=episode_part,
-            offset=episode_offset,
+            format=transer_item.episode_format,
+            detail=transer_item.episode_detail,
+            part=transer_item.episode_part,
+            offset=transer_item.episode_offset,
         )
     # 开始转移
-    state, errormsg = TransferChain(db).manual_transfer(
-        in_path=in_path,
-        target=target,
-        tmdbid=tmdbid,
+    state, errormsg = TransferChain().manual_transfer(
+        fileitem=src_fileitem,
+        target_storage=transer_item.target_storage,
+        target_path=target_path,
+        tmdbid=transer_item.tmdbid,
+        doubanid=transer_item.doubanid,
         mtype=mtype,
-        season=season,
-        transfer_type=transfer_type,
+        season=transer_item.season,
+        episode_group=transer_item.episode_group,
+        transfer_type=transer_item.transfer_type,
         epformat=epformat,
-        min_filesize=min_filesize
+        min_filesize=transer_item.min_filesize,
+        scrape=transer_item.scrape,
+        library_type_folder=transer_item.library_type_folder,
+        library_category_folder=transer_item.library_category_folder,
+        force=force,
+        background=background
     )
     # 失败
     if not state:
@@ -77,3 +163,12 @@ def manual_transfer(path: str,
         return schemas.Response(success=False, message=errormsg)
     # 成功
     return schemas.Response(success=True)
+
+
+@router.get("/now", summary="立即执行下载器文件整理", response_model=schemas.Response)
+def now(_: Annotated[str, Depends(verify_apitoken)]) -> Any:
+    """
+    立即执行下载器文件整理 API_TOKEN认证（?token=xxx）
+    """
+    TransferChain().process()
+    return schemas.Response(success=True)

app/api/endpoints/user.py

@@ -1,22 +1,25 @@
 import base64
-from typing import Any, List
+import re
+from typing import Annotated, Any, List, Union
 
-from fastapi import APIRouter, Depends, HTTPException, UploadFile, File
+from fastapi import APIRouter, Body, Depends, HTTPException, UploadFile, File
 from sqlalchemy.orm import Session
 
 from app import schemas
 from app.core.security import get_password_hash
 from app.db import get_db
 from app.db.models.user import User
-from app.db.userauth import get_current_active_superuser, get_current_active_user
+from app.db.user_oper import get_current_active_superuser, get_current_active_user
+from app.db.userconfig_oper import UserConfigOper
+from app.utils.otp import OtpUtils
 
 router = APIRouter()
 
 
 @router.get("/", summary="所有用户", response_model=List[schemas.User])
-def read_users(
-    db: Session = Depends(get_db),
-    current_user: User = Depends(get_current_active_superuser),
+def list_users(
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_active_superuser),
 ) -> Any:
     """
     查询用户列表
@@ -27,10 +30,10 @@ def read_users(
 
 @router.post("/", summary="新增用户", response_model=schemas.Response)
 def create_user(
-    *,
-    db: Session = Depends(get_db),
-    user_in: schemas.UserCreate,
-    current_user: User = Depends(get_current_active_superuser),
+        *,
+        db: Session = Depends(get_db),
+        user_in: schemas.UserCreate,
+        current_user: User = Depends(get_current_active_superuser),
 ) -> Any:
     """
     新增用户
@@ -49,19 +52,32 @@ def create_user(
 
 @router.put("/", summary="更新用户", response_model=schemas.Response)
 def update_user(
-    *,
-    db: Session = Depends(get_db),
-    user_in: schemas.UserCreate,
-    _: User = Depends(get_current_active_superuser),
+        *,
+        db: Session = Depends(get_db),
+        user_in: schemas.UserUpdate,
+        _: User = Depends(get_current_active_superuser),
 ) -> Any:
     """
     更新用户
     """
     user_info = user_in.dict()
     if user_info.get("password"):
+        # 正则表达式匹配密码包含字母、数字、特殊字符中的至少两项
+        pattern = r'^(?![a-zA-Z]+$)(?!\d+$)(?![^\da-zA-Z\s]+$).{6,50}$'
+        if not re.match(pattern, user_info.get("password")):
+            return schemas.Response(success=False,
+                                    message="密码需要同时包含字母、数字、特殊字符中的至少两项，且长度大于6位")
         user_info["hashed_password"] = get_password_hash(user_info["password"])
         user_info.pop("password")
-    user = User.get_by_name(db, name=user_info["name"])
+    user = User.get_by_id(db, user_id=user_info["id"])
+    user_name = user_info.get("name")
+    if not user_name:
+        return schemas.Response(success=False, message="用户名不能为空")
+    # 新用户名去重
+    users = User.list(db)
+    for u in users:
+        if u.name == user_name and u.id != user_info["id"]:
+            return schemas.Response(success=False, message="用户名已被使用")
     if not user:
         return schemas.Response(success=False, message="用户不存在")
     user.update(db, user_info)
@@ -70,7 +86,7 @@ def update_user(
 
 @router.get("/current", summary="当前登录用户信息", response_model=schemas.User)
 def read_current_user(
-    current_user: User = Depends(get_current_active_user)
+        current_user: User = Depends(get_current_active_user)
 ) -> Any:
     """
     当前登录用户信息
@@ -79,8 +95,8 @@ def read_current_user(
 
 
 @router.post("/avatar/{user_id}", summary="上传用户头像", response_model=schemas.Response)
-async def upload_avatar(user_id: int, db: Session = Depends(get_db),
-                        file: UploadFile = File(...)):
+def upload_avatar(user_id: int, db: Session = Depends(get_db), file: UploadFile = File(...),
+                  _: User = Depends(get_current_active_user)):
     """
     上传用户头像
     """
@@ -96,15 +112,96 @@ async def upload_avatar(user_id: int, db: Session = Depends(get_db),
     return schemas.Response(success=True, message=file.filename)
 
 
-@router.delete("/{user_name}", summary="删除用户", response_model=schemas.Response)
-def delete_user(
-    *,
-    db: Session = Depends(get_db),
-    user_name: str,
-    current_user: User = Depends(get_current_active_superuser),
+@router.post('/otp/generate', summary='生成otp验证uri', response_model=schemas.Response)
+def otp_generate(
+        current_user: User = Depends(get_current_active_user)
+) -> Any:
+    secret, uri = OtpUtils.generate_secret_key(current_user.name)
+    return schemas.Response(success=secret != "", data={'secret': secret, 'uri': uri})
+
+
+@router.post('/otp/judge', summary='判断otp验证是否通过', response_model=schemas.Response)
+def otp_judge(
+        data: dict,
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_active_user)
+) -> Any:
+    uri = data.get("uri")
+    otp_password = data.get("otpPassword")
+    if not OtpUtils.is_legal(uri, otp_password):
+        return schemas.Response(success=False, message="验证码错误")
+    current_user.update_otp_by_name(db, current_user.name, True, OtpUtils.get_secret(uri))
+    return schemas.Response(success=True)
+
+
+@router.post('/otp/disable', summary='关闭当前用户的otp验证', response_model=schemas.Response)
+def otp_disable(
+        db: Session = Depends(get_db),
+        current_user: User = Depends(get_current_active_user)
+) -> Any:
+    current_user.update_otp_by_name(db, current_user.name, False, "")
+    return schemas.Response(success=True)
+
+
+@router.get('/otp/{userid}', summary='判断当前用户是否开启otp验证', response_model=schemas.Response)
+def otp_enable(userid: str, db: Session = Depends(get_db)) -> Any:
+    user: User = User.get_by_name(db, userid)
+    if not user:
+        return schemas.Response(success=False)
+    return schemas.Response(success=user.is_otp)
+
+
+@router.get("/config/{key}", summary="查询用户配置", response_model=schemas.Response)
+def get_config(key: str,
+               current_user: User = Depends(get_current_active_user)):
+    """
+    查询用户配置
+    """
+    value = UserConfigOper().get(username=current_user.name, key=key)
+    return schemas.Response(success=True, data={
+        "value": value
+    })
+
+
+@router.post("/config/{key}", summary="更新用户配置", response_model=schemas.Response)
+def set_config(
+    key: str,
+    value: Annotated[Union[list, dict, bool, int, str] | None, Body()] = None,
+    current_user: User = Depends(get_current_active_user),
+):
+    """
+    更新用户配置
+    """
+    UserConfigOper().set(username=current_user.name, key=key, value=value)
+    return schemas.Response(success=True)
+
+
+@router.delete("/id/{user_id}", summary="删除用户", response_model=schemas.Response)
+def delete_user_by_id(
+        *,
+        db: Session = Depends(get_db),
+        user_id: int,
+        current_user: User = Depends(get_current_active_superuser),
 ) -> Any:
     """
-    删除用户
+    通过唯一ID删除用户
+    """
+    user = current_user.get_by_id(db, user_id=user_id)
+    if not user:
+        return schemas.Response(success=False, message="用户不存在")
+    user.delete_by_id(db, user_id)
+    return schemas.Response(success=True)
+
+
+@router.delete("/name/{user_name}", summary="删除用户", response_model=schemas.Response)
+def delete_user_by_name(
+        *,
+        db: Session = Depends(get_db),
+        user_name: str,
+        current_user: User = Depends(get_current_active_superuser),
+) -> Any:
+    """
+    通过用户名删除用户
     """
     user = current_user.get_by_name(db, name=user_name)
     if not user:
@@ -113,16 +210,16 @@ def delete_user(
     return schemas.Response(success=True)
 
 
-@router.get("/{user_id}", summary="用户详情", response_model=schemas.User)
-def read_user_by_id(
-    user_id: int,
-    current_user: User = Depends(get_current_active_user),
-    db: Session = Depends(get_db),
+@router.get("/{username}", summary="用户详情", response_model=schemas.User)
+def read_user_by_name(
+        username: str,
+        current_user: User = Depends(get_current_active_user),
+        db: Session = Depends(get_db),
 ) -> Any:
     """
     查询用户详情
     """
-    user = current_user.get(db, rid=user_id)
+    user = current_user.get_by_name(db, name=username)
     if not user:
         raise HTTPException(
             status_code=404,
@@ -130,7 +227,7 @@ def read_user_by_id(
         )
     if user == current_user:
         return user
-    if not user.is_superuser:
+    if not current_user.is_superuser:
         raise HTTPException(
             status_code=400,
             detail="用户权限不足"

app/api/endpoints/webhook.py

@@ -1,48 +1,42 @@
-from typing import Any
+from typing import Any, Annotated
 
 from fastapi import APIRouter, BackgroundTasks, Request, Depends
-from sqlalchemy.orm import Session
 
 from app import schemas
 from app.chain.webhook import WebhookChain
-from app.core.config import settings
-from app.db import get_db
+from app.core.security import verify_apitoken
 
 router = APIRouter()
 
 
-def start_webhook_chain(db: Session, body: Any, form: Any, args: Any):
+def start_webhook_chain(body: Any, form: Any, args: Any):
     """
     启动链式任务
     """
-    WebhookChain(db).message(body=body, form=form, args=args)
+    WebhookChain().message(body=body, form=form, args=args)
 
 
 @router.post("/", summary="Webhook消息响应", response_model=schemas.Response)
 async def webhook_message(background_tasks: BackgroundTasks,
-                          token: str, request: Request,
-                          db: Session = Depends(get_db),) -> Any:
+                          request: Request,
+                          _: Annotated[str, Depends(verify_apitoken)]
+                          ) -> Any:
     """
-    Webhook响应
+    Webhook响应，配置请求中需要添加参数：token=API_TOKEN&source=媒体服务器名
     """
-    if token != settings.API_TOKEN:
-        return schemas.Response(success=False, message="token认证不通过")
     body = await request.body()
     form = await request.form()
     args = request.query_params
-    background_tasks.add_task(start_webhook_chain, db, body, form, args)
+    background_tasks.add_task(start_webhook_chain, body, form, args)
     return schemas.Response(success=True)
 
 
 @router.get("/", summary="Webhook消息响应", response_model=schemas.Response)
-async def webhook_message(background_tasks: BackgroundTasks,
-                          token: str, request: Request,
-                          db: Session = Depends(get_db)) -> Any:
+def webhook_message(background_tasks: BackgroundTasks,
+                    request: Request, _: Annotated[str, Depends(verify_apitoken)]) -> Any:
     """
-    Webhook响应
+    Webhook响应，配置请求中需要添加参数：token=API_TOKEN&source=媒体服务器名
     """
-    if token != settings.API_TOKEN:
-        return schemas.Response(success=False, message="token认证不通过")
     args = request.query_params
-    background_tasks.add_task(start_webhook_chain, db, None, None, args)
+    background_tasks.add_task(start_webhook_chain, None, None, args)
     return schemas.Response(success=True)

app/api/endpoints/workflow.py

@@ -0,0 +1,171 @@
+from datetime import datetime
+from typing import List, Any, Optional
+
+from fastapi import APIRouter, Depends
+from sqlalchemy.orm import Session
+
+from app import schemas
+from app.core.config import global_vars
+from app.core.plugin import PluginManager
+from app.core.workflow import WorkFlowManager
+from app.db import get_db
+from app.db.models.workflow import Workflow
+from app.db.systemconfig_oper import SystemConfigOper
+from app.db.user_oper import get_current_active_user
+from app.chain.workflow import WorkflowChain
+from app.scheduler import Scheduler
+
+router = APIRouter()
+
+
+@router.get("/", summary="所有工作流", response_model=List[schemas.Workflow])
+def list_workflows(db: Session = Depends(get_db),
+                   _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    获取工作流列表
+    """
+    return Workflow.list(db)
+
+
+@router.post("/", summary="创建工作流", response_model=schemas.Response)
+def create_workflow(workflow: schemas.Workflow,
+                    db: Session = Depends(get_db),
+                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    创建工作流
+    """
+    if Workflow.get_by_name(db, workflow.name):
+        return schemas.Response(success=False, message="已存在相同名称的工作流")
+    if not workflow.add_time:
+        workflow.add_time = datetime.strftime(datetime.now(), "%Y-%m-%d %H:%M:%S")
+    if not workflow.state:
+        workflow.state = "P"
+    Workflow(**workflow.dict()).create(db)
+    return schemas.Response(success=True, message="创建工作流成功")
+
+
+@router.get("/plugin/actions", summary="查询插件动作", response_model=List[dict])
+def list_plugin_actions(plugin_id: str = None, _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    获取所有动作
+    """
+    return PluginManager().get_plugin_actions(plugin_id)
+
+
+@router.get("/actions", summary="所有动作", response_model=List[dict])
+def list_actions(_: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    获取所有动作
+    """
+    return WorkFlowManager().list_actions()
+
+
+@router.get("/{workflow_id}", summary="工作流详情", response_model=schemas.Workflow)
+def get_workflow(workflow_id: int,
+                 db: Session = Depends(get_db),
+                 _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    获取工作流详情
+    """
+    return Workflow.get(db, workflow_id)
+
+
+@router.put("/{workflow_id}", summary="更新工作流", response_model=schemas.Response)
+def update_workflow(workflow: schemas.Workflow,
+                    db: Session = Depends(get_db),
+                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    更新工作流
+    """
+    wf = Workflow.get(db, workflow.id)
+    if not wf:
+        return schemas.Response(success=False, message="工作流不存在")
+    wf.update(db, workflow.dict())
+    return schemas.Response(success=True, message="更新成功")
+
+
+@router.delete("/{workflow_id}", summary="删除工作流", response_model=schemas.Response)
+def delete_workflow(workflow_id: int,
+                    db: Session = Depends(get_db),
+                    _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    删除工作流
+    """
+    workflow = Workflow.get(db, workflow_id)
+    if not workflow:
+        return schemas.Response(success=False, message="工作流不存在")
+    # 删除定时任务
+    Scheduler().remove_workflow_job(workflow)
+    # 删除工作流
+    Workflow.delete(db, workflow_id)
+    # 删除缓存
+    SystemConfigOper().delete(f"WorkflowCache-{workflow_id}")
+    return schemas.Response(success=True, message="删除成功")
+
+
+@router.post("/{workflow_id}/run", summary="执行工作流", response_model=schemas.Response)
+def run_workflow(workflow_id: int,
+                 from_begin: Optional[bool] = True,
+                 _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    执行工作流
+    """
+    state, errmsg = WorkflowChain().process(workflow_id, from_begin=from_begin)
+    if not state:
+        return schemas.Response(success=False, message=errmsg)
+    return schemas.Response(success=True)
+
+
+@router.post("/{workflow_id}/start", summary="启用工作流", response_model=schemas.Response)
+def start_workflow(workflow_id: int,
+                   db: Session = Depends(get_db),
+                   _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    启用工作流
+    """
+    workflow = Workflow.get(db, workflow_id)
+    if not workflow:
+        return schemas.Response(success=False, message="工作流不存在")
+    # 添加定时任务
+    Scheduler().update_workflow_job(workflow)
+    # 更新状态
+    workflow.update_state(db, workflow_id, "W")
+    return schemas.Response(success=True)
+
+
+@router.post("/{workflow_id}/pause", summary="停用工作流", response_model=schemas.Response)
+def pause_workflow(workflow_id: int,
+                   db: Session = Depends(get_db),
+                   _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    停用工作流
+    """
+    workflow = Workflow.get(db, workflow_id)
+    if not workflow:
+        return schemas.Response(success=False, message="工作流不存在")
+    # 删除定时任务
+    Scheduler().remove_workflow_job(workflow)
+    # 停止工作流
+    global_vars.stop_workflow(workflow_id)
+    # 更新状态
+    workflow.update_state(db, workflow_id, "P")
+    return schemas.Response(success=True)
+
+
+@router.post("/{workflow_id}/reset", summary="重置工作流", response_model=schemas.Response)
+def reset_workflow(workflow_id: int,
+                   db: Session = Depends(get_db),
+                   _: schemas.TokenPayload = Depends(get_current_active_user)) -> Any:
+    """
+    重置工作流
+    """
+    workflow = Workflow.get(db, workflow_id)
+    if not workflow:
+        return schemas.Response(success=False, message="工作流不存在")
+    # 停止工作流
+    global_vars.stop_workflow(workflow_id)
+    # 重置工作流
+    workflow.reset(db, workflow_id, reset_count=True)
+    # 删除缓存
+    SystemConfigOper().delete(f"WorkflowCache-{workflow_id}")
+    return schemas.Response(success=True)

app/api/servarr.py

@@ -1,13 +1,14 @@
-from typing import Any, List
+from typing import Any, List, Annotated
 
 from fastapi import APIRouter, HTTPException, Depends
 from sqlalchemy.orm import Session
 
 from app import schemas
 from app.chain.media import MediaChain
+from app.chain.tvdb import TvdbChain
 from app.chain.subscribe import SubscribeChain
-from app.core.config import settings
 from app.core.metainfo import MetaInfo
+from app.core.security import verify_apikey
 from app.db import get_db
 from app.db.models.subscribe import Subscribe
 from app.schemas import RadarrMovie, SonarrSeries
@@ -18,15 +19,10 @@ arr_router = APIRouter(tags=['servarr'])
 
 
 @arr_router.get("/system/status", summary="系统状态")
-def arr_system_status(apikey: str) -> Any:
+def arr_system_status(_: Annotated[str, Depends(verify_apikey)]) -> Any:
     """
     模拟Radarr、Sonarr系统状态
     """
-    if not apikey or apikey != settings.API_TOKEN:
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
     return {
         "appName": "MoviePilot",
         "instanceName": "moviepilot",
@@ -77,15 +73,10 @@ def arr_system_status(apikey: str) -> Any:
 
 
 @arr_router.get("/qualityProfile", summary="质量配置")
-def arr_qualityProfile(apikey: str) -> Any:
+def arr_qualityProfile(_: Annotated[str, Depends(verify_apikey)]) -> Any:
     """
     模拟Radarr、Sonarr质量配置
     """
-    if not apikey or apikey != settings.API_TOKEN:
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
     return [
         {
             "id": 1,
@@ -123,19 +114,14 @@ def arr_qualityProfile(apikey: str) -> Any:
 
 
 @arr_router.get("/rootfolder", summary="根目录")
-def arr_rootfolder(apikey: str) -> Any:
+def arr_rootfolder(_: Annotated[str, Depends(verify_apikey)]) -> Any:
     """
     模拟Radarr、Sonarr根目录
     """
-    if not apikey or apikey != settings.API_TOKEN:
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
     return [
         {
             "id": 1,
-            "path": "/" if not settings.LIBRARY_PATHS else str(settings.LIBRARY_PATHS[0]),
+            "path": "/",
             "accessible": True,
             "freeSpace": 0,
             "unmappedFolders": []
@@ -144,15 +130,10 @@ def arr_rootfolder(apikey: str) -> Any:
 
 
 @arr_router.get("/tag", summary="标签")
-def arr_tag(apikey: str) -> Any:
+def arr_tag(_: Annotated[str, Depends(verify_apikey)]) -> Any:
     """
     模拟Radarr、Sonarr标签
     """
-    if not apikey or apikey != settings.API_TOKEN:
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
     return [
         {
             "id": 1,
@@ -162,15 +143,10 @@ def arr_tag(apikey: str) -> Any:
 
 
 @arr_router.get("/languageprofile", summary="语言")
-def arr_languageprofile(apikey: str) -> Any:
+def arr_languageprofile(_: Annotated[str, Depends(verify_apikey)]) -> Any:
     """
     模拟Radarr、Sonarr语言
     """
-    if not apikey or apikey != settings.API_TOKEN:
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
     return [{
         "id": 1,
         "name": "默认",
@@ -193,7 +169,7 @@ def arr_languageprofile(apikey: str) -> Any:
 
 
 @arr_router.get("/movie", summary="所有订阅电影", response_model=List[schemas.RadarrMovie])
-def arr_movies(apikey: str, db: Session = Depends(get_db)) -> Any:
+def arr_movies(_: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     查询Rardar电影
     """
@@ -262,11 +238,6 @@ def arr_movies(apikey: str, db: Session = Depends(get_db)) -> Any:
       }
     ]
     """
-    if not apikey or apikey != settings.API_TOKEN:
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
     # 查询所有电影订阅
     result = []
     subscribes = Subscribe.list(db)
@@ -289,23 +260,18 @@ def arr_movies(apikey: str, db: Session = Depends(get_db)) -> Any:
 
 
 @arr_router.get("/movie/lookup", summary="查询电影", response_model=List[schemas.RadarrMovie])
-def arr_movie_lookup(apikey: str, term: str, db: Session = Depends(get_db)) -> Any:
+def arr_movie_lookup(term: str, _: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     查询Rardar电影 term: `tmdb:${id}`
     存在和不存在均不能返回错误
     """
-    if not apikey or apikey != settings.API_TOKEN:
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
     tmdbid = term.replace("tmdb:", "")
     # 查询媒体信息
-    mediainfo = MediaChain(db).recognize_media(mtype=MediaType.MOVIE, tmdbid=int(tmdbid))
+    mediainfo = MediaChain().recognize_media(mtype=MediaType.MOVIE, tmdbid=int(tmdbid))
     if not mediainfo:
         return [RadarrMovie()]
     # 查询是否已存在
-    exists = MediaChain(db).media_exists(mediainfo=mediainfo)
+    exists = MediaChain().media_exists(mediainfo=mediainfo)
     if not exists:
         # 文件不存在
         hasfile = False
@@ -340,15 +306,10 @@ def arr_movie_lookup(apikey: str, term: str, db: Session = Depends(get_db)) -> A
 
 
 @arr_router.get("/movie/{mid}", summary="电影订阅详情", response_model=schemas.RadarrMovie)
-def arr_movie(apikey: str, mid: int, db: Session = Depends(get_db)) -> Any:
+def arr_movie(mid: int, _: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     查询Rardar电影订阅
     """
-    if not apikey or apikey != settings.API_TOKEN:
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
     subscribe = Subscribe.get(db, mid)
     if subscribe:
         return RadarrMovie(
@@ -371,18 +332,13 @@ def arr_movie(apikey: str, mid: int, db: Session = Depends(get_db)) -> Any:
 
 
 @arr_router.post("/movie", summary="新增电影订阅")
-def arr_add_movie(apikey: str,
+def arr_add_movie(_: Annotated[str, Depends(verify_apikey)],
                   movie: RadarrMovie,
-                  db: Session = Depends(get_db),
+                  db: Session = Depends(get_db)
                   ) -> Any:
     """
     新增Rardar电影订阅
     """
-    if not apikey or apikey != settings.API_TOKEN:
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
     # 检查订阅是否已存在
     subscribe = Subscribe.get_by_tmdbid(db, movie.tmdbId)
     if subscribe:
@@ -390,11 +346,11 @@ def arr_add_movie(apikey: str,
             "id": subscribe.id
         }
     # 添加订阅
-    sid, message = SubscribeChain(db).add(title=movie.title,
-                                          year=movie.year,
-                                          mtype=MediaType.MOVIE,
-                                          tmdbid=movie.tmdbId,
-                                          userid="Seerr")
+    sid, message = SubscribeChain().add(title=movie.title,
+                                        year=movie.year,
+                                        mtype=MediaType.MOVIE,
+                                        tmdbid=movie.tmdbId,
+                                        username="Seerr")
     if sid:
         return {
             "id": sid
@@ -407,15 +363,10 @@ def arr_add_movie(apikey: str,
 
 
 @arr_router.delete("/movie/{mid}", summary="删除电影订阅", response_model=schemas.Response)
-def arr_remove_movie(apikey: str, mid: int, db: Session = Depends(get_db)) -> Any:
+def arr_remove_movie(mid: int, _: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     删除Rardar电影订阅
     """
-    if not apikey or apikey != settings.API_TOKEN:
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
     subscribe = Subscribe.get(db, mid)
     if subscribe:
         subscribe.delete(db, mid)
@@ -428,7 +379,7 @@ def arr_remove_movie(apikey: str, mid: int, db: Session = Depends(get_db)) -> An
 
 
 @arr_router.get("/series", summary="所有剧集", response_model=List[schemas.SonarrSeries])
-def arr_series(apikey: str, db: Session = Depends(get_db)) -> Any:
+def arr_series(_: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     查询Sonarr剧集
     """
@@ -534,11 +485,6 @@ def arr_series(apikey: str, db: Session = Depends(get_db)) -> Any:
       }
     ]
     """
-    if not apikey or apikey != settings.API_TOKEN:
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
     # 查询所有电视剧订阅
     result = []
     subscribes = Subscribe.list(db)
@@ -569,110 +515,100 @@ def arr_series(apikey: str, db: Session = Depends(get_db)) -> Any:
 
 
 @arr_router.get("/series/lookup", summary="查询剧集")
-def arr_series_lookup(apikey: str, term: str, db: Session = Depends(get_db)) -> Any:
+def arr_series_lookup(term: str, _: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     查询Sonarr剧集 term: `tvdb:${id}` title
     """
-    if not apikey or apikey != settings.API_TOKEN:
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
-
-    # 获取TVDBID
-    if not term.startswith("tvdb:"):
-        mediainfo = MediaChain(db).recognize_media(meta=MetaInfo(term),
-                                                   mtype=MediaType.TV)
-        if not mediainfo:
-            return [SonarrSeries()]
-        tvdbid = mediainfo.tvdb_id
-        if not tvdbid:
-            return [SonarrSeries()]
-    else:
-        mediainfo = None
-        tvdbid = int(term.replace("tvdb:", ""))
-
-    # 查询TVDB信息
-    tvdbinfo = MediaChain(db).tvdb_info(tvdbid=tvdbid)
-    if not tvdbinfo:
-        return [SonarrSeries()]
-
     # 季信息
     seas: List[int] = []
-    sea_num = tvdbinfo.get('season')
-    if sea_num:
-        seas = list(range(1, int(sea_num) + 1))
-
-    # 根据TVDB查询媒体信息
-    if not mediainfo:
-        mediainfo = MediaChain(db).recognize_media(meta=MetaInfo(tvdbinfo.get('seriesName')),
-                                                   mtype=MediaType.TV)
-
-    # 查询是否存在
-    exists = MediaChain(db).media_exists(mediainfo)
-    if exists:
-        hasfile = True
+    # tvdbid 列表
+    tvdbids: List[int] = []
+    # 获取TVDBID
+    if not term.startswith("tvdb:"):
+        title = term.replace("+", " ")
+        tvdbids = TvdbChain().get_tvdbid_by_name(title=title)
     else:
-        hasfile = False
+        tvdbid = int(term.replace("tvdb:", ""))
+        tvdbids.append(tvdbid)
 
-    # 查询订阅信息
-    seasons: List[dict] = []
-    subscribes = Subscribe.get_by_tmdbid(db, mediainfo.tmdb_id)
-    if subscribes:
-        # 已监控
-        monitored = True
-        # 已监控季
-        sub_seas = [sub.season for sub in subscribes]
-        for sea in seas:
-            if sea in sub_seas:
-                seasons.append({
-                    "seasonNumber": sea,
-                    "monitored": True,
-                })
-            else:
+    sonarr_series_list = []
+    for tvdbid in tvdbids:
+        # 查询TVDB信息
+        tvdbinfo = MediaChain().tvdb_info(tvdbid=tvdbid)
+        if not tvdbinfo:
+            continue
+
+        # 季信息(只取默认季类型，排除特别季)
+        sea_num = len([season for season in tvdbinfo.get('seasons') if
+                       season['type']['id'] == tvdbinfo.get('defaultSeasonType') and season['number'] > 0])
+        if sea_num:
+            seas = list(range(1, int(sea_num) + 1))
+
+        # 根据TVDB查询媒体信息
+        mediainfo = MediaChain().recognize_media(meta=MetaInfo(tvdbinfo.get('name')),
+                                                 mtype=MediaType.TV)
+        if not mediainfo:
+            continue
+        # 查询是否存在
+        exists = MediaChain().media_exists(mediainfo)
+        if exists:
+            hasfile = True
+        else:
+            hasfile = False
+
+        # 查询订阅信息
+        seasons: List[dict] = []
+        subscribes = Subscribe.get_by_tmdbid(db, mediainfo.tmdb_id)
+        if subscribes:
+            # 已监控
+            monitored = True
+            # 已监控季
+            sub_seas = [sub.season for sub in subscribes]
+            for sea in seas:
+                if sea in sub_seas:
+                    seasons.append({
+                        "seasonNumber": sea,
+                        "monitored": True,
+                    })
+                else:
+                    seasons.append({
+                        "seasonNumber": sea,
+                        "monitored": False,
+                    })
+            subid = subscribes[-1].id
+        else:
+            subid = None
+            monitored = False
+            for sea in seas:
                 seasons.append({
                     "seasonNumber": sea,
                     "monitored": False,
                 })
-        subid = subscribes[-1].id
-    else:
-        subid = None
-        monitored = False
-        for sea in seas:
-            seasons.append({
-                "seasonNumber": sea,
-                "monitored": False,
-            })
+        sonarr_series = SonarrSeries(
+            id=subid,
+            title=mediainfo.title,
+            seasonCount=len(seasons),
+            seasons=seasons,
+            remotePoster=mediainfo.get_poster_image(),
+            year=mediainfo.year,
+            tmdbId=mediainfo.tmdb_id,
+            tvdbId=tvdbid,
+            imdbId=mediainfo.imdb_id,
+            profileId=1,
+            languageProfileId=1,
+            monitored=monitored,
+            hasFile=hasfile,
+        )
+        sonarr_series_list.append(sonarr_series)
 
-    return [SonarrSeries(
-        id=subid,
-        title=mediainfo.title,
-        seasonCount=len(seasons),
-        seasons=seasons,
-        remotePoster=mediainfo.get_poster_image(),
-        year=mediainfo.year,
-        tmdbId=mediainfo.tmdb_id,
-        tvdbId=mediainfo.tvdb_id,
-        imdbId=mediainfo.imdb_id,
-        profileId=1,
-        languageProfileId=1,
-        qualityProfileId=1,
-        isAvailable=True,
-        monitored=monitored,
-        hasFile=hasfile
-    )]
+    return sonarr_series_list if sonarr_series_list else [SonarrSeries()]
 
 
 @arr_router.get("/series/{tid}", summary="剧集详情")
-def arr_serie(apikey: str, tid: int, db: Session = Depends(get_db)) -> Any:
+def arr_serie(tid: int, _: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     查询Sonarr剧集
     """
-    if not apikey or apikey != settings.API_TOKEN:
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
     subscribe = Subscribe.get(db, tid)
     if subscribe:
         return SonarrSeries(
@@ -703,16 +639,12 @@ def arr_serie(apikey: str, tid: int, db: Session = Depends(get_db)) -> Any:
 
 
 @arr_router.post("/series", summary="新增剧集订阅")
-def arr_add_series(apikey: str, tv: schemas.SonarrSeries,
+def arr_add_series(tv: schemas.SonarrSeries,
+                   _: Annotated[str, Depends(verify_apikey)],
                    db: Session = Depends(get_db)) -> Any:
     """
     新增Sonarr剧集订阅
     """
-    if not apikey or apikey != settings.API_TOKEN:
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
     # 检查订阅是否存在
     left_seasons = []
     for season in tv.seasons:
@@ -732,12 +664,12 @@ def arr_add_series(apikey: str, tv: schemas.SonarrSeries,
     for season in left_seasons:
         if not season.get("monitored"):
             continue
-        sid, message = SubscribeChain(db).add(title=tv.title,
-                                              year=tv.year,
-                                              season=season.get("seasonNumber"),
-                                              tmdbid=tv.tmdbId,
-                                              mtype=MediaType.TV,
-                                              userid="Seerr")
+        sid, message = SubscribeChain().add(title=tv.title,
+                                            year=tv.year,
+                                            season=season.get("seasonNumber"),
+                                            tmdbid=tv.tmdbId,
+                                            mtype=MediaType.TV,
+                                            username="Seerr")
 
     if sid:
         return {
@@ -750,16 +682,19 @@ def arr_add_series(apikey: str, tv: schemas.SonarrSeries,
         )
 
 
+@arr_router.put("/series", summary="更新剧集订阅")
+def arr_update_series(tv: schemas.SonarrSeries) -> Any:
+    """
+    更新Sonarr剧集订阅
+    """
+    return arr_add_series(tv)
+
+
 @arr_router.delete("/series/{tid}", summary="删除剧集订阅")
-def arr_remove_series(apikey: str, tid: int, db: Session = Depends(get_db)) -> Any:
+def arr_remove_series(tid: int, _: Annotated[str, Depends(verify_apikey)], db: Session = Depends(get_db)) -> Any:
     """
     删除Sonarr剧集订阅
     """
-    if not apikey or apikey != settings.API_TOKEN:
-        raise HTTPException(
-            status_code=403,
-            detail="认证失败！",
-        )
     subscribe = Subscribe.get(db, tid)
     if subscribe:
         subscribe.delete(db, tid)

app/api/servcookie.py

@@ -0,0 +1,134 @@
+import gzip
+import json
+from typing import Annotated, Callable, Any, Dict, Optional
+
+from fastapi import APIRouter, Depends, HTTPException, Path, Request, Response
+from fastapi.responses import PlainTextResponse
+from fastapi.routing import APIRoute
+
+from app import schemas
+from app.core.config import settings
+from app.log import logger
+from app.utils.crypto import CryptoJsUtils, HashUtils
+
+
+class GzipRequest(Request):
+
+    async def body(self) -> bytes:
+        if not hasattr(self, "_body"):
+            body = await super().body()
+            if "gzip" in self.headers.getlist("Content-Encoding"):
+                body = gzip.decompress(body)
+            self._body = body # noqa
+        return self._body
+
+
+class GzipRoute(APIRoute):
+
+    def get_route_handler(self) -> Callable:
+        original_route_handler = super().get_route_handler()
+
+        async def custom_route_handler(request: Request) -> Response:
+            request = GzipRequest(request.scope, request.receive)
+            return await original_route_handler(request)
+
+        return custom_route_handler
+
+
+async def verify_server_enabled():
+    """
+    校验CookieCloud服务路由是否打开
+    """
+    if not settings.COOKIECLOUD_ENABLE_LOCAL:
+        raise HTTPException(status_code=400, detail="本地CookieCloud服务器未启用")
+    return True
+
+
+cookie_router = APIRouter(route_class=GzipRoute,
+                          tags=["servcookie"],
+                          dependencies=[Depends(verify_server_enabled)])
+
+
+@cookie_router.get("/", response_class=PlainTextResponse)
+def get_root():
+    return "Hello MoviePilot! COOKIECLOUD API ROOT = /cookiecloud"
+
+
+@cookie_router.post("/", response_class=PlainTextResponse)
+def post_root():
+    return "Hello MoviePilot! COOKIECLOUD API ROOT = /cookiecloud"
+
+
+@cookie_router.post("/update")
+async def update_cookie(req: schemas.CookieData):
+    """
+    上传Cookie数据
+    """
+    file_path = settings.COOKIE_PATH / f"{req.uuid}.json"
+    content = json.dumps({"encrypted": req.encrypted})
+    with open(file_path, encoding="utf-8", mode="w") as file:
+        file.write(content)
+    with open(file_path, encoding="utf-8", mode="r") as file:
+        read_content = file.read()
+    if read_content == content:
+        return {"action": "done"}
+    else:
+        return {"action": "error"}
+
+
+def load_encrypt_data(uuid: str) -> Dict[str, Any]:
+    """
+    加载本地加密原始数据
+    """
+    file_path = settings.COOKIE_PATH / f"{uuid}.json"
+
+    # 检查文件是否存在
+    if not file_path.exists():
+        raise HTTPException(status_code=404, detail="Item not found")
+
+    # 读取文件
+    with open(file_path, encoding="utf-8", mode="r") as file:
+        read_content = file.read()
+    data = json.loads(read_content.encode("utf-8"))
+    return data
+
+
+def get_decrypted_cookie_data(uuid: str, password: str,
+                              encrypted: str) -> Optional[Dict[str, Any]]:
+    """
+    加载本地加密数据并解密为Cookie
+    """
+    combined_string = f"{uuid}-{password}"
+    aes_key = HashUtils.md5(combined_string)[:16].encode("utf-8")
+
+    if encrypted:
+        try:
+            decrypted_data = CryptoJsUtils.decrypt(encrypted, aes_key).decode("utf-8")
+            decrypted_data = json.loads(decrypted_data)
+            if "cookie_data" in decrypted_data:
+                return decrypted_data
+        except Exception as e:
+            logger.error(f"解密Cookie数据失败：{str(e)}")
+            return None
+    else:
+        return None
+
+
+@cookie_router.get("/get/{uuid}")
+async def get_cookie(
+        uuid: Annotated[str, Path(min_length=5, pattern="^[a-zA-Z0-9]+$")]):
+    """
+    GET 下载加密数据
+    """
+    return load_encrypt_data(uuid)
+
+
+@cookie_router.post("/get/{uuid}")
+async def post_cookie(
+        uuid: Annotated[str, Path(min_length=5, pattern="^[a-zA-Z0-9]+$")],
+        request: schemas.CookiePassword):
+    """
+    POST 下载加密数据
+    """
+    data = load_encrypt_data(uuid)
+    return get_decrypted_cookie_data(uuid, request.password, data["encrypted"])

app/chain/__init__.py

@@ -1,25 +1,28 @@
-import gc
+import copy
 import pickle
 import traceback
 from abc import ABCMeta
+from collections.abc import Callable
 from pathlib import Path
 from typing import Optional, Any, Tuple, List, Set, Union, Dict
 
 from qbittorrentapi import TorrentFilesList
-from ruamel.yaml import CommentedMap
-from sqlalchemy.orm import Session
 from transmission_rpc import File
 
 from app.core.config import settings
-from app.core.context import Context
-from app.core.context import MediaInfo, TorrentInfo
+from app.core.context import Context, MediaInfo, TorrentInfo
 from app.core.event import EventManager
 from app.core.meta import MetaBase
 from app.core.module import ModuleManager
+from app.core.plugin import PluginManager
+from app.db.message_oper import MessageOper
+from app.db.user_oper import UserOper
+from app.helper.message import MessageHelper, MessageQueueManager, MessageTemplateHelper
+from app.helper.service import ServiceConfigHelper
 from app.log import logger
 from app.schemas import TransferInfo, TransferTorrent, ExistMediaInfo, DownloadingTorrent, CommingMessage, Notification, \
-    WebhookEventInfo, TmdbEpisode
-from app.schemas.types import TorrentStatus, MediaType, MediaImageType, EventType
+    WebhookEventInfo, TmdbEpisode, MediaPerson, FileItem, TransferDirectoryConf
+from app.schemas.types import TorrentStatus, MediaType, MediaImageType, EventType, MessageChannel
 from app.utils.object import ObjectUtils
 
 
@@ -28,13 +31,18 @@ class ChainBase(metaclass=ABCMeta):
     处理链基类
     """
 
-    def __init__(self, db: Session = None):
+    def __init__(self):
         """
         公共初始化
         """
-        self._db = db
         self.modulemanager = ModuleManager()
         self.eventmanager = EventManager()
+        self.messageoper = MessageOper()
+        self.messagehelper = MessageHelper()
+        self.messagequeue = MessageQueueManager(
+            send_callback=self.run_module
+        )
+        self.pluginmanager = PluginManager()
 
     @staticmethod
     def load_cache(filename: str) -> Any:
@@ -47,7 +55,7 @@ class ChainBase(metaclass=ABCMeta):
                 with open(cache_path, 'rb') as f:
                     return pickle.load(f)
             except Exception as err:
-                logger.error(f"加载缓存 {filename} 出错：{err}")
+                logger.error(f"加载缓存 {filename} 出错：{str(err)}")
         return None
 
     @staticmethod
@@ -57,17 +65,23 @@ class ChainBase(metaclass=ABCMeta):
         """
         try:
             with open(settings.TEMP_PATH / filename, 'wb') as f:
-                pickle.dump(cache, f)
+                pickle.dump(cache, f)  # noqa
         except Exception as err:
-            logger.error(f"保存缓存 {filename} 出错：{err}")
-        finally:
-            # 主动资源回收
-            del cache
-            gc.collect()
+            logger.error(f"保存缓存 {filename} 出错：{str(err)}")
+
+    @staticmethod
+    def remove_cache(filename: str) -> None:
+        """
+        删除本地缓存
+        """
+        cache_path = settings.TEMP_PATH / filename
+        if cache_path.exists():
+            cache_path.unlink()
 
     def run_module(self, method: str, *args, **kwargs) -> Any:
         """
         运行包含该方法的所有模块，然后返回结果
+        当kwargs包含命名参数raise_exception时，如模块方法抛出异常且raise_exception为True，则同步抛出异常
         """
 
         def is_result_empty(ret):
@@ -77,22 +91,69 @@ class ChainBase(metaclass=ABCMeta):
             if isinstance(ret, tuple):
                 return all(value is None for value in ret)
             else:
-                return result is None
+                return ret is None
 
-        logger.debug(f"请求模块执行：{method} ...")
         result = None
-        modules = self.modulemanager.get_modules(method)
-        for module in modules:
+        # 插件模块
+        for plugin, module_dict in self.pluginmanager.get_plugin_modules().items():
+            plugin_id, plugin_name = plugin
+            if method in module_dict:
+                func = module_dict[method]
+                if func:
+                    try:
+                        logger.info(f"请求插件 {plugin_name} 执行：{method} ...")
+                        if is_result_empty(result):
+                            # 返回None，第一次执行或者需继续执行下一模块
+                            result = func(*args, **kwargs)
+                        elif isinstance(result, list):
+                            # 返回为列表，有多个模块运行结果时进行合并
+                            temp = func(*args, **kwargs)
+                            if isinstance(temp, list):
+                                result.extend(temp)
+                        else:
+                            break
+                    except Exception as err:
+                        if kwargs.get("raise_exception"):
+                            raise
+                        logger.error(
+                            f"运行插件 {plugin_id} 模块 {method} 出错：{str(err)}\n{traceback.format_exc()}")
+                        self.messagehelper.put(title=f"{plugin_name} 发生了错误",
+                                               message=str(err),
+                                               role="plugin")
+                        self.eventmanager.send_event(
+                            EventType.SystemError,
+                            {
+                                "type": "plugin",
+                                "plugin_id": plugin_id,
+                                "plugin_name": plugin_name,
+                                "plugin_method": method,
+                                "error": str(err),
+                                "traceback": traceback.format_exc()
+                            }
+                        )
+        if not is_result_empty(result) and not isinstance(result, list):
+            # 插件模块返回结果不为空且不是列表，直接返回
+            return result
+
+        # 系统模块
+        logger.debug(f"请求系统模块执行：{method} ...")
+        for module in sorted(self.modulemanager.get_running_modules(method), key=lambda x: x.get_priority()):
+            module_id = module.__class__.__name__
+            try:
+                module_name = module.get_name()
+            except Exception as err:
+                logger.debug(f"获取模块名称出错：{str(err)}")
+                module_name = module_id
             try:
                 func = getattr(module, method)
                 if is_result_empty(result):
                     # 返回None，第一次执行或者需继续执行下一模块
                     result = func(*args, **kwargs)
                 elif ObjectUtils.check_signature(func, result):
-                    # 返回结果与方法签名一致，将结果传入（不能多个模块同时运行的需要通过开关控制）
+                    # 返回结果与方法签名一致，将结果传入
                     result = func(result)
                 elif isinstance(result, list):
-                    # 返回为列表，有多个模块运行结果时进行合并（不能多个模块同时运行的需要通过开关控制）
+                    # 返回为列表，有多个模块运行结果时进行合并
                     temp = func(*args, **kwargs)
                     if isinstance(temp, list):
                         result.extend(temp)
@@ -100,31 +161,85 @@ class ChainBase(metaclass=ABCMeta):
                     # 中止继续执行
                     break
             except Exception as err:
-                logger.error(f"运行模块 {method} 出错：{module.__class__.__name__} - {err}\n{traceback.print_exc()}")
+                if kwargs.get("raise_exception"):
+                    raise
+                logger.error(
+                    f"运行模块 {module_id}.{method} 出错：{str(err)}\n{traceback.format_exc()}")
+                self.messagehelper.put(title=f"{module_name}发生了错误",
+                                       message=str(err),
+                                       role="system")
+                self.eventmanager.send_event(
+                    EventType.SystemError,
+                    {
+                        "type": "module",
+                        "module_id": module_id,
+                        "module_name": module_name,
+                        "module_method": method,
+                        "error": str(err),
+                        "traceback": traceback.format_exc()
+                    }
+                )
         return result
 
     def recognize_media(self, meta: MetaBase = None,
-                        mtype: MediaType = None,
-                        tmdbid: int = None) -> Optional[MediaInfo]:
+                        mtype: Optional[MediaType] = None,
+                        tmdbid: Optional[int] = None,
+                        doubanid: Optional[str] = None,
+                        bangumiid: Optional[int] = None,
+                        episode_group: Optional[str] = None,
+                        cache: bool = True) -> Optional[MediaInfo]:
         """
-        识别媒体信息
+        识别媒体信息，不含Fanart图片
         :param meta:     识别的元数据
         :param mtype:    识别的媒体类型，与tmdbid配套
         :param tmdbid:   tmdbid
+        :param doubanid: 豆瓣ID
+        :param bangumiid: BangumiID
+        :param episode_group: 剧集组
+        :param cache:    是否使用缓存
         :return: 识别的媒体信息，包括剧集信息
         """
-        return self.run_module("recognize_media", meta=meta, mtype=mtype, tmdbid=tmdbid)
+        # 识别用名中含指定信息情形
+        if not mtype and meta and meta.type in [MediaType.TV, MediaType.MOVIE]:
+            mtype = meta.type
+        if not tmdbid and hasattr(meta, "tmdbid"):
+            tmdbid = meta.tmdbid
+        if not doubanid and hasattr(meta, "doubanid"):
+            doubanid = meta.doubanid
+        # 有tmdbid时不使用其它ID
+        if tmdbid:
+            doubanid = None
+            bangumiid = None
+        return self.run_module("recognize_media", meta=meta, mtype=mtype,
+                               tmdbid=tmdbid, doubanid=doubanid, bangumiid=bangumiid,
+                               episode_group=episode_group, cache=cache)
 
-    def match_doubaninfo(self, name: str, mtype: str = None,
-                         year: str = None, season: int = None) -> Optional[dict]:
+    def match_doubaninfo(self, name: str, imdbid: Optional[str] = None,
+                         mtype: Optional[MediaType] = None, year: Optional[str] = None, season: Optional[int] = None,
+                         raise_exception: bool = False) -> Optional[dict]:
         """
         搜索和匹配豆瓣信息
         :param name: 标题
+        :param imdbid: imdbid
+        :param mtype: 类型
+        :param year: 年份
+        :param season: 季
+        :param raise_exception: 触发速率限制时是否抛出异常
+        """
+        return self.run_module("match_doubaninfo", name=name, imdbid=imdbid,
+                               mtype=mtype, year=year, season=season, raise_exception=raise_exception)
+
+    def match_tmdbinfo(self, name: str, mtype: Optional[MediaType] = None,
+                       year: Optional[str] = None, season: Optional[int] = None) -> Optional[dict]:
+        """
+        搜索和匹配TMDB信息
+        :param name: 标题
         :param mtype: 类型
         :param year: 年份
         :param season: 季
         """
-        return self.run_module("match_doubaninfo", name=name, mtype=mtype, year=year, season=season)
+        return self.run_module("match_tmdbinfo", name=name,
+                               mtype=mtype, year=year, season=season)
 
     def obtain_images(self, mediainfo: MediaInfo) -> Optional[MediaInfo]:
         """
@@ -135,8 +250,8 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("obtain_images", mediainfo=mediainfo)
 
     def obtain_specific_image(self, mediaid: Union[str, int], mtype: MediaType,
-                              image_type: MediaImageType, image_prefix: str = None,
-                              season: int = None, episode: int = None) -> Optional[str]:
+                              image_type: MediaImageType, image_prefix: Optional[str] = None,
+                              season: Optional[int] = None, episode: Optional[int] = None) -> Optional[str]:
         """
         获取指定媒体信息图片，返回图片地址
         :param mediaid:     媒体ID
@@ -150,13 +265,16 @@ class ChainBase(metaclass=ABCMeta):
                                image_prefix=image_prefix, image_type=image_type,
                                season=season, episode=episode)
 
-    def douban_info(self, doubanid: str) -> Optional[dict]:
+    def douban_info(self, doubanid: str, mtype: Optional[MediaType] = None,
+                    raise_exception: bool = False) -> Optional[dict]:
         """
         获取豆瓣信息
         :param doubanid: 豆瓣ID
+        :param mtype: 媒体类型
         :return: 豆瓣信息
+        :param raise_exception: 触发速率限制时是否抛出异常
         """
-        return self.run_module("douban_info", doubanid=doubanid)
+        return self.run_module("douban_info", doubanid=doubanid, mtype=mtype, raise_exception=raise_exception)
 
     def tvdb_info(self, tvdbid: int) -> Optional[dict]:
         """
@@ -166,28 +284,38 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("tvdb_info", tvdbid=tvdbid)
 
-    def tmdb_info(self, tmdbid: int, mtype: MediaType) -> Optional[dict]:
+    def tmdb_info(self, tmdbid: int, mtype: MediaType, season: Optional[int] = None) -> Optional[dict]:
         """
         获取TMDB信息
         :param tmdbid: int
         :param mtype:  媒体类型
+        :param season: 季
         :return: TVDB信息
         """
-        return self.run_module("tmdb_info", tmdbid=tmdbid, mtype=mtype)
+        return self.run_module("tmdb_info", tmdbid=tmdbid, mtype=mtype, season=season)
 
-    def message_parser(self, body: Any, form: Any,
+    def bangumi_info(self, bangumiid: int) -> Optional[dict]:
+        """
+        获取Bangumi信息
+        :param bangumiid: int
+        :return: Bangumi信息
+        """
+        return self.run_module("bangumi_info", bangumiid=bangumiid)
+
+    def message_parser(self, source: str, body: Any, form: Any,
                        args: Any) -> Optional[CommingMessage]:
         """
         解析消息内容，返回字典，注意以下约定值：
         userid: 用户ID
         username: 用户名
         text: 内容
+        :param source: 消息来源（渠道配置名称）
         :param body: 请求体
         :param form: 表单
         :param args: 参数
         :return: 消息渠道、消息内容
         """
-        return self.run_module("message_parser", body=body, form=form, args=args)
+        return self.run_module("message_parser", source=source, body=body, form=form, args=args)
 
     def webhook_parser(self, body: Any, form: Any, args: Any) -> Optional[WebhookEventInfo]:
         """
@@ -207,10 +335,24 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("search_medias", meta=meta)
 
-    def search_torrents(self, site: CommentedMap,
+    def search_persons(self, name: str) -> Optional[List[MediaPerson]]:
+        """
+        搜索人物信息
+        :param name:  人物名称
+        """
+        return self.run_module("search_persons", name=name)
+
+    def search_collections(self, name: str) -> Optional[List[MediaInfo]]:
+        """
+        搜索集合信息
+        :param name:  集合名称
+        """
+        return self.run_module("search_collections", name=name)
+
+    def search_torrents(self, site: dict,
                         keywords: List[str],
-                        mtype: MediaType = None,
-                        page: int = 0) -> List[TorrentInfo]:
+                        mtype: Optional[MediaType] = None,
+                        page: Optional[int] = 0) -> List[TorrentInfo]:
         """
         搜索一个站点的种子资源
         :param site:  站点
@@ -222,33 +364,35 @@ class ChainBase(metaclass=ABCMeta):
         return self.run_module("search_torrents", site=site, keywords=keywords,
                                mtype=mtype, page=page)
 
-    def refresh_torrents(self, site: CommentedMap) -> List[TorrentInfo]:
+    def refresh_torrents(self, site: dict, keyword: Optional[str] = None,
+                         cat: Optional[str] = None, page: Optional[int] = 0) -> List[TorrentInfo]:
         """
         获取站点最新一页的种子，多个站点需要多线程处理
         :param site:  站点
+        :param keyword:  标题
+        :param cat:  分类
+        :param page:  页码
         :reutrn: 种子资源列表
         """
-        return self.run_module("refresh_torrents", site=site)
+        return self.run_module("refresh_torrents", site=site, keyword=keyword, cat=cat, page=page)
 
-    def filter_torrents(self, rule_string: str,
+    def filter_torrents(self, rule_groups: List[str],
                         torrent_list: List[TorrentInfo],
-                        season_episodes: Dict[int, list] = None,
                         mediainfo: MediaInfo = None) -> List[TorrentInfo]:
         """
         过滤种子资源
-        :param rule_string:  过滤规则
+        :param rule_groups:  过滤规则组名称列表
         :param torrent_list:  资源列表
-        :param season_episodes:  季集数过滤 {season:[episodes]}
         :param mediainfo:  识别的媒体信息
         :return: 过滤后的资源列表，添加资源优先级
         """
-        return self.run_module("filter_torrents", rule_string=rule_string,
-                               torrent_list=torrent_list, season_episodes=season_episodes,
-                               mediainfo=mediainfo)
+        return self.run_module("filter_torrents", rule_groups=rule_groups,
+                               torrent_list=torrent_list, mediainfo=mediainfo)
 
     def download(self, content: Union[Path, str], download_dir: Path, cookie: str,
-                 episodes: Set[int] = None, category: str = None
-                 ) -> Optional[Tuple[Optional[str], str]]:
+                 episodes: Set[int] = None, category: Optional[str] = None, label: Optional[str] = None,
+                 downloader: Optional[str] = None
+                 ) -> Optional[Tuple[Optional[str], Optional[str], Optional[str], str]]:
         """
         根据种子文件，选择并添加下载任务
         :param content:  种子文件地址或者磁力链接
@@ -256,10 +400,13 @@ class ChainBase(metaclass=ABCMeta):
         :param cookie:  cookie
         :param episodes:  需要下载的集数
         :param category:  种子分类
-        :return: 种子Hash，错误信息
+        :param label:  标签
+        :param downloader:  下载器
+        :return: 下载器名称、种子Hash、种子文件布局、错误原因
         """
         return self.run_module("download", content=content, download_dir=download_dir,
-                               cookie=cookie, episodes=episodes, category=category)
+                               cookie=cookie, episodes=episodes, category=category, label=label,
+                               downloader=downloader)
 
     def download_added(self, context: Context, download_dir: Path, torrent_path: Path = None) -> None:
         """
@@ -273,137 +420,252 @@ class ChainBase(metaclass=ABCMeta):
                                download_dir=download_dir)
 
     def list_torrents(self, status: TorrentStatus = None,
-                      hashs: Union[list, str] = None) -> Optional[List[Union[TransferTorrent, DownloadingTorrent]]]:
+                      hashs: Union[list, str] = None,
+                      downloader: Optional[str] = None
+                      ) -> Optional[List[Union[TransferTorrent, DownloadingTorrent]]]:
         """
         获取下载器种子列表
         :param status:  种子状态
         :param hashs:  种子Hash
+        :param downloader:  下载器
         :return: 下载器中符合状态的种子列表
         """
-        return self.run_module("list_torrents", status=status, hashs=hashs)
+        return self.run_module("list_torrents", status=status, hashs=hashs, downloader=downloader)
 
-    def transfer(self, path: Path, meta: MetaBase, mediainfo: MediaInfo,
-                 transfer_type: str, target: Path = None,
-                 episodes_info: List[TmdbEpisode] = None) -> Optional[TransferInfo]:
+    def transfer(self, fileitem: FileItem, meta: MetaBase, mediainfo: MediaInfo,
+                 target_directory: TransferDirectoryConf = None,
+                 target_storage: Optional[str] = None, target_path: Path = None,
+                 transfer_type: Optional[str] = None, scrape: bool = None,
+                 library_type_folder: bool = None, library_category_folder: bool = None,
+                 episodes_info: List[TmdbEpisode] = None,
+                 source_oper: Callable = None, target_oper: Callable = None) -> Optional[TransferInfo]:
         """
         文件转移
-        :param path:  文件路径
+        :param fileitem:  文件信息
         :param meta: 预识别的元数据
         :param mediainfo:  识别的媒体信息
+        :param target_directory:  目标目录配置
+        :param target_storage:  目标存储
+        :param target_path:  目标路径
         :param transfer_type:  转移模式
-        :param target:  转移目标路径
+        :param scrape: 是否刮削元数据
+        :param library_type_folder: 是否按类型创建目录
+        :param library_category_folder: 是否按类别创建目录
         :param episodes_info: 当前季的全部集信息
+        :param source_oper:  源存储操作类
+        :param target_oper:  目标存储操作类
         :return: {path, target_path, message}
         """
-        return self.run_module("transfer", path=path, meta=meta, mediainfo=mediainfo,
-                               transfer_type=transfer_type, target=target,
-                               episodes_info=episodes_info)
+        return self.run_module("transfer",
+                               fileitem=fileitem, meta=meta, mediainfo=mediainfo,
+                               target_directory=target_directory,
+                               target_path=target_path, target_storage=target_storage,
+                               transfer_type=transfer_type, scrape=scrape,
+                               library_type_folder=library_type_folder,
+                               library_category_folder=library_category_folder,
+                               episodes_info=episodes_info,
+                               source_oper=source_oper, target_oper=target_oper)
 
-    def transfer_completed(self, hashs: Union[str, list], path: Path = None) -> None:
+    def transfer_completed(self, hashs: str, downloader: Optional[str] = None) -> None:
         """
-        转移完成后的处理
+        下载器转移完成后的处理
         :param hashs:  种子Hash
-        :param path:  源目录
+        :param downloader:  下载器
         """
-        return self.run_module("transfer_completed", hashs=hashs, path=path)
+        return self.run_module("transfer_completed", hashs=hashs, downloader=downloader)
 
-    def remove_torrents(self, hashs: Union[str, list]) -> bool:
+    def remove_torrents(self, hashs: Union[str, list], delete_file: bool = True,
+                        downloader: Optional[str] = None) -> bool:
         """
         删除下载器种子
         :param hashs:  种子Hash
+        :param delete_file: 是否删除文件
+        :param downloader:  下载器
         :return: bool
         """
-        return self.run_module("remove_torrents", hashs=hashs)
+        return self.run_module("remove_torrents", hashs=hashs, delete_file=delete_file, downloader=downloader)
 
-    def start_torrents(self, hashs: Union[list, str]) -> bool:
+    def start_torrents(self, hashs: Union[list, str], downloader: Optional[str] = None) -> bool:
         """
         开始下载
         :param hashs:  种子Hash
+        :param downloader:  下载器
         :return: bool
         """
-        return self.run_module("start_torrents", hashs=hashs)
+        return self.run_module("start_torrents", hashs=hashs, downloader=downloader)
 
-    def stop_torrents(self, hashs: Union[list, str]) -> bool:
+    def stop_torrents(self, hashs: Union[list, str], downloader: Optional[str] = None) -> bool:
         """
         停止下载
         :param hashs:  种子Hash
+        :param downloader:  下载器
         :return: bool
         """
-        return self.run_module("stop_torrents", hashs=hashs)
+        return self.run_module("stop_torrents", hashs=hashs, downloader=downloader)
 
-    def torrent_files(self, tid: str) -> Optional[Union[TorrentFilesList, List[File]]]:
+    def torrent_files(self, tid: str,
+                      downloader: Optional[str] = None) -> Optional[Union[TorrentFilesList, List[File]]]:
         """
         获取种子文件
         :param tid:  种子Hash
+        :param downloader:  下载器
         :return: 种子文件
         """
-        return self.run_module("torrent_files", tid=tid)
+        return self.run_module("torrent_files", tid=tid, downloader=downloader)
 
-    def media_exists(self, mediainfo: MediaInfo, itemid: str = None) -> Optional[ExistMediaInfo]:
+    def media_exists(self, mediainfo: MediaInfo, itemid: Optional[str] = None,
+                     server: Optional[str] = None) -> Optional[ExistMediaInfo]:
         """
         判断媒体文件是否存在
         :param mediainfo:  识别的媒体信息
         :param itemid:  媒体服务器ItemID
+        :param server:  媒体服务器
         :return: 如不存在返回None，存在时返回信息，包括每季已存在所有集{type: movie/tv, seasons: {season: [episodes]}}
         """
-        return self.run_module("media_exists", mediainfo=mediainfo, itemid=itemid)
+        return self.run_module("media_exists", mediainfo=mediainfo, itemid=itemid, server=server)
 
-    def refresh_mediaserver(self, mediainfo: MediaInfo, file_path: Path) -> None:
+    def media_files(self, mediainfo: MediaInfo) -> Optional[List[FileItem]]:
         """
-        刷新媒体库
+        获取媒体文件清单
         :param mediainfo:  识别的媒体信息
-        :param file_path:  文件路径
-        :return: 成功或失败
+        :return: 媒体文件列表
         """
-        self.run_module("refresh_mediaserver", mediainfo=mediainfo, file_path=file_path)
+        return self.run_module("media_files", mediainfo=mediainfo)
 
-    def post_message(self, message: Notification) -> None:
+    def post_message(self,
+                     message: Optional[Notification] = None,
+                     meta: Optional[MetaBase] = None,
+                     mediainfo: Optional[MediaInfo] = None,
+                     torrentinfo: Optional[TorrentInfo] = None,
+                     transferinfo: Optional[TransferInfo] = None,
+                     **kwargs) -> None:
         """
         发送消息
-        :param message:  消息体
+        :param message:  Notification实例
+        :param meta:  元数据
+        :param mediainfo:  媒体信息
+        :param torrentinfo:  种子信息
+        :param transferinfo:  文件整理信息
+        :param kwargs:  其他参数(覆盖业务对象属性值)
         :return: 成功或失败
         """
-        # 发送事件
-        self.eventmanager.send_event(etype=EventType.NoticeMessage,
-                                     data={
-                                         "channel": message.channel,
-                                         "title": message.title,
-                                         "text": message.text,
-                                         "image": message.image,
-                                         "userid": message.userid,
-                                     })
-        logger.info(f"发送消息：channel={message.channel}，"
-                    f"title={message.title}, "
-                    f"text={message.text}，"
-                    f"userid={message.userid}")
-        self.run_module("post_message", message=message)
+        # 渲染消息
+        message = MessageTemplateHelper.render(message=message, meta=meta, mediainfo=mediainfo,
+                                               torrentinfo=torrentinfo, transferinfo=transferinfo, **kwargs)
+        # 保存消息
+        self.messagehelper.put(message, role="user", title=message.title)
+        self.messageoper.add(**message.dict())
+        # 发送消息按设置隔离
+        if not message.userid and message.mtype:
+            # 消息隔离设置
+            notify_action = ServiceConfigHelper.get_notification_switch(message.mtype)
+            if notify_action:
+                # 'admin' 'user,admin' 'user' 'all'
+                actions = notify_action.split(",")
+                # 是否已发送管理员标志
+                admin_sended = False
+                send_orignal = False
+                useroper = UserOper()
+                for action in actions:
+                    send_message = copy.deepcopy(message)
+                    if action == "admin" and not admin_sended:
+                        # 仅发送管理员
+                        logger.info(f"{send_message.mtype} 的消息已设置发送给管理员")
+                        # 读取管理员消息IDS
+                        send_message.targets = useroper.get_settings(settings.SUPERUSER)
+                        admin_sended = True
+                    elif action == "user" and send_message.username:
+                        # 发送对应用户
+                        logger.info(f"{send_message.mtype} 的消息已设置发送给用户 {send_message.username}")
+                        # 读取用户消息IDS
+                        send_message.targets = useroper.get_settings(send_message.username)
+                        if send_message.targets is None:
+                            # 没有找到用户
+                            if not admin_sended:
+                                # 回滚发送管理员
+                                logger.info(f"用户 {send_message.username} 不存在，消息将发送给管理员")
+                                # 读取管理员消息IDS
+                                send_message.targets = useroper.get_settings(settings.SUPERUSER)
+                                admin_sended = True
+                            else:
+                                # 管理员发过了，此消息不发了
+                                logger.info(f"用户 {send_message.username} 不存在，消息无法发送到对应用户")
+                                continue
+                        elif send_message.username == settings.SUPERUSER:
+                            # 管理员同名已发送
+                            admin_sended = True
+                    else:
+                        # 按原消息发送全体
+                        if not admin_sended:
+                            send_orignal = True
+                        break
+                    # 按设定发送
+                    self.eventmanager.send_event(etype=EventType.NoticeMessage,
+                                                 data={**send_message.dict(), "type": send_message.mtype})
+                    self.messagequeue.send_message("post_message", message=send_message)
+                if not send_orignal:
+                    return
+        # 发送消息事件
+        self.eventmanager.send_event(etype=EventType.NoticeMessage, data={**message.dict(), "type": message.mtype})
+        # 按原消息发送
+        self.messagequeue.send_message("post_message", message=message,
+                                       immediately=True if message.userid else False)
 
-    def post_medias_message(self, message: Notification, medias: List[MediaInfo]) -> Optional[bool]:
+    def post_medias_message(self, message: Notification, medias: List[MediaInfo]) -> None:
         """
         发送媒体信息选择列表
         :param message:  消息体
         :param medias:  媒体列表
         :return: 成功或失败
         """
-        return self.run_module("post_medias_message", message=message, medias=medias)
+        note_list = [media.to_dict() for media in medias]
+        self.messagehelper.put(message, role="user", note=note_list, title=message.title)
+        self.messageoper.add(**message.dict(), note=note_list)
+        return self.messagequeue.send_message("post_medias_message", message=message, medias=medias,
+                                              immediately=True if message.userid else False)
 
-    def post_torrents_message(self, message: Notification, torrents: List[Context]) -> Optional[bool]:
+    def post_torrents_message(self, message: Notification, torrents: List[Context]) -> None:
         """
         发送种子信息选择列表
         :param message:  消息体
         :param torrents:  种子列表
         :return: 成功或失败
         """
-        return self.run_module("post_torrents_message", message=message, torrents=torrents)
+        note_list = [torrent.torrent_info.to_dict() for torrent in torrents]
+        self.messagehelper.put(message, role="user", note=note_list, title=message.title)
+        self.messageoper.add(**message.dict(), note=note_list)
+        return self.messagequeue.send_message("post_torrents_message", message=message, torrents=torrents,
+                                              immediately=True if message.userid else False)
 
-    def scrape_metadata(self, path: Path, mediainfo: MediaInfo) -> None:
+    def delete_message(self, channel: MessageChannel, source: str,
+                       message_id: Union[str, int], chat_id: Optional[Union[str, int]] = None) -> bool:
         """
-        刮削元数据
-        :param path: 媒体文件路径
-        :param mediainfo:  识别的媒体信息
-        :return: 成功或失败
+        删除消息
+        :param channel: 消息渠道
+        :param source: 消息源（指定特定的消息模块）
+        :param message_id: 消息ID
+        :param chat_id: 聊天ID（如群组ID）
+        :return: 删除是否成功
         """
-        self.run_module("scrape_metadata", path=path, mediainfo=mediainfo)
+        return self.run_module("delete_message", channel=channel, source=source,
+                               message_id=message_id, chat_id=chat_id)
+
+    def metadata_img(self, mediainfo: MediaInfo,
+                     season: Optional[int] = None, episode: Optional[int] = None) -> Optional[dict]:
+        """
+        获取图片名称和url
+        :param mediainfo: 媒体信息
+        :param season: 季号
+        :param episode: 集号
+        """
+        return self.run_module("metadata_img", mediainfo=mediainfo, season=season, episode=episode)
+
+    def media_category(self) -> Optional[Dict[str, list]]:
+        """
+        获取媒体分类
+        :return: 获取二级分类配置字典项，需包括电影、电视剧
+        """
+        return self.run_module("media_category")
 
     def register_commands(self, commands: Dict[str, dict]) -> None:
         """

app/chain/bangumi.py

@@ -0,0 +1,59 @@
+from typing import Optional, List
+
+from app import schemas
+from app.chain import ChainBase
+from app.core.context import MediaInfo
+
+
+class BangumiChain(ChainBase):
+    """
+    Bangumi处理链
+    """
+
+    def calendar(self) -> Optional[List[MediaInfo]]:
+        """
+        获取Bangumi每日放送
+        """
+        return self.run_module("bangumi_calendar")
+
+    def discover(self, **kwargs) -> Optional[List[MediaInfo]]:
+        """
+        发现Bangumi番剧
+        """
+        return self.run_module("bangumi_discover", **kwargs)
+
+    def bangumi_info(self, bangumiid: int) -> Optional[dict]:
+        """
+        获取Bangumi信息
+        :param bangumiid: BangumiID
+        :return: Bangumi信息
+        """
+        return self.run_module("bangumi_info", bangumiid=bangumiid)
+
+    def bangumi_credits(self, bangumiid: int) -> List[schemas.MediaPerson]:
+        """
+        根据BangumiID查询电影演职员表
+        :param bangumiid:  BangumiID
+        """
+        return self.run_module("bangumi_credits", bangumiid=bangumiid)
+
+    def bangumi_recommend(self, bangumiid: int) -> Optional[List[MediaInfo]]:
+        """
+        根据BangumiID查询推荐电影
+        :param bangumiid:  BangumiID
+        """
+        return self.run_module("bangumi_recommend", bangumiid=bangumiid)
+
+    def person_detail(self, person_id: int) -> Optional[schemas.MediaPerson]:
+        """
+        根据人物ID查询Bangumi人物详情
+        :param person_id:  人物ID
+        """
+        return self.run_module("bangumi_person_detail", person_id=person_id)
+
+    def person_credits(self, person_id: int) -> Optional[List[MediaInfo]]:
+        """
+        根据人物ID查询人物参演作品
+        :param person_id:  人物ID
+        """
+        return self.run_module("bangumi_person_credits", person_id=person_id)

app/chain/cookiecloud.py

@@ -1,179 +0,0 @@
-import base64
-from typing import Tuple, Optional
-from urllib.parse import urljoin
-
-from lxml import etree
-from sqlalchemy.orm import Session
-
-from app.chain import ChainBase
-from app.chain.site import SiteChain
-from app.core.config import settings
-from app.db.site_oper import SiteOper
-from app.db.siteicon_oper import SiteIconOper
-from app.helper.cloudflare import under_challenge
-from app.helper.cookiecloud import CookieCloudHelper
-from app.helper.message import MessageHelper
-from app.helper.rss import RssHelper
-from app.helper.sites import SitesHelper
-from app.log import logger
-from app.utils.http import RequestUtils
-from app.utils.site import SiteUtils
-
-
-class CookieCloudChain(ChainBase):
-    """
-    CookieCloud处理链
-    """
-
-    def __init__(self, db: Session = None):
-        super().__init__(db)
-        self.siteoper = SiteOper(self._db)
-        self.siteiconoper = SiteIconOper(self._db)
-        self.siteshelper = SitesHelper()
-        self.rsshelper = RssHelper()
-        self.sitechain = SiteChain(self._db)
-        self.message = MessageHelper()
-        self.cookiecloud = CookieCloudHelper(
-            server=settings.COOKIECLOUD_HOST,
-            key=settings.COOKIECLOUD_KEY,
-            password=settings.COOKIECLOUD_PASSWORD
-        )
-
-    def process(self, manual=False) -> Tuple[bool, str]:
-        """
-        通过CookieCloud同步站点Cookie
-        """
-        logger.info("开始同步CookieCloud站点 ...")
-        cookies, msg = self.cookiecloud.download()
-        if not cookies:
-            logger.error(f"CookieCloud同步失败：{msg}")
-            if manual:
-                self.message.put(f"CookieCloud同步失败： {msg}")
-            return False, msg
-        # 保存Cookie或新增站点
-        _update_count = 0
-        _add_count = 0
-        _fail_count = 0
-        for domain, cookie in cookies.items():
-            # 获取站点信息
-            indexer = self.siteshelper.get_indexer(domain)
-            site_info = self.siteoper.get_by_domain(domain)
-            if site_info:
-                # 检查站点连通性
-                status, msg = self.sitechain.test(domain)
-                # 更新站点Cookie
-                if status:
-                    logger.info(f"站点【{site_info.name}】连通性正常，不同步CookieCloud数据")
-                    # 更新站点rss地址
-                    if not site_info.public and not site_info.rss:
-                        # 自动生成rss地址
-                        rss_url, errmsg = self.rsshelper.get_rss_link(
-                            url=site_info.url,
-                            cookie=cookie,
-                            ua=settings.USER_AGENT,
-                            proxy=True if site_info.proxy else False
-                        )
-                        if rss_url:
-                            logger.info(f"更新站点 {domain} RSS地址 ...")
-                            self.siteoper.update_rss(domain=domain, rss=rss_url)
-                        else:
-                            logger.warn(errmsg)
-                    continue
-                # 更新站点Cookie
-                logger.info(f"更新站点 {domain} Cookie ...")
-                self.siteoper.update_cookie(domain=domain, cookies=cookie)
-                _update_count += 1
-            elif indexer:
-                # 新增站点
-                res = RequestUtils(cookies=cookie,
-                                   ua=settings.USER_AGENT
-                                   ).get_res(url=indexer.get("domain"))
-                if res and res.status_code in [200, 500, 403]:
-                    if not indexer.get("public") and not SiteUtils.is_logged_in(res.text):
-                        _fail_count += 1
-                        if under_challenge(res.text):
-                            logger.warn(f"站点 {indexer.get('name')} 被Cloudflare防护，无法登录，无法添加站点")
-                            continue
-                        logger.warn(
-                            f"站点 {indexer.get('name')} 登录失败，没有该站点账号或Cookie已失效，无法添加站点")
-                        continue
-                elif res is not None:
-                    _fail_count += 1
-                    logger.warn(f"站点 {indexer.get('name')} 连接状态码：{res.status_code}，无法添加站点")
-                    continue
-                else:
-                    _fail_count += 1
-                    logger.warn(f"站点 {indexer.get('name')} 连接失败，无法添加站点")
-                    continue
-                # 获取rss地址
-                rss_url = None
-                if not indexer.get("public") and indexer.get("domain"):
-                    # 自动生成rss地址
-                    rss_url, errmsg = self.rsshelper.get_rss_link(url=indexer.get("domain"),
-                                                                  cookie=cookie,
-                                                                  ua=settings.USER_AGENT)
-                    if errmsg:
-                        logger.warn(errmsg)
-                # 插入数据库
-                logger.info(f"新增站点 {indexer.get('name')} ...")
-                self.siteoper.add(name=indexer.get("name"),
-                                  url=indexer.get("domain"),
-                                  domain=domain,
-                                  cookie=cookie,
-                                  rss=rss_url,
-                                  public=1 if indexer.get("public") else 0)
-                _add_count += 1
-
-            # 保存站点图标
-            if indexer:
-                site_icon = self.siteiconoper.get_by_domain(domain)
-                if not site_icon or not site_icon.base64:
-                    logger.info(f"开始缓存站点 {indexer.get('name')} 图标 ...")
-                    icon_url, icon_base64 = self.__parse_favicon(url=indexer.get("domain"),
-                                                                 cookie=cookie,
-                                                                 ua=settings.USER_AGENT)
-                    if icon_url:
-                        self.siteiconoper.update_icon(name=indexer.get("name"),
-                                                      domain=domain,
-                                                      icon_url=icon_url,
-                                                      icon_base64=icon_base64)
-                        logger.info(f"缓存站点 {indexer.get('name')} 图标成功")
-                    else:
-                        logger.warn(f"缓存站点 {indexer.get('name')} 图标失败")
-        # 处理完成
-        ret_msg = f"更新了{_update_count}个站点，新增了{_add_count}个站点"
-        if _fail_count > 0:
-            ret_msg += f"，{_fail_count}个站点添加失败，下次同步时将重试，也可以手动添加"
-        if manual:
-            self.message.put(f"CookieCloud同步成功, {ret_msg}")
-        logger.info(f"CookieCloud同步成功：{ret_msg}")
-        return True, ret_msg
-
-    @staticmethod
-    def __parse_favicon(url: str, cookie: str, ua: str) -> Tuple[str, Optional[str]]:
-        """
-        解析站点favicon,返回base64 fav图标
-        :param url: 站点地址
-        :param cookie: Cookie
-        :param ua: User-Agent
-        :return:
-        """
-        favicon_url = urljoin(url, "favicon.ico")
-        res = RequestUtils(cookies=cookie, timeout=60, ua=ua).get_res(url=url)
-        if res:
-            html_text = res.text
-        else:
-            logger.error(f"获取站点页面失败：{url}")
-            return favicon_url, None
-        html = etree.HTML(html_text)
-        if html:
-            fav_link = html.xpath('//head/link[contains(@rel, "icon")]/@href')
-            if fav_link:
-                favicon_url = urljoin(url, fav_link[0])
-
-        res = RequestUtils(cookies=cookie, timeout=20, ua=ua).get_res(url=favicon_url)
-        if res:
-            return favicon_url, base64.b64encode(res.content).decode()
-        else:
-            logger.error(f"获取站点图标失败：{favicon_url}")
-        return favicon_url, None

app/chain/dashboard.py

@@ -8,14 +8,14 @@ class DashboardChain(ChainBase):
     """
     各类仪表板统计处理链
     """
-    def media_statistic(self) -> Optional[List[schemas.Statistic]]:
+    def media_statistic(self, server: Optional[str] = None) -> Optional[List[schemas.Statistic]]:
         """
         媒体数量统计
         """
-        return self.run_module("media_statistic")
+        return self.run_module("media_statistic", server=server)
 
-    def downloader_info(self) -> schemas.DownloaderInfo:
+    def downloader_info(self, downloader: Optional[str] = None) -> Optional[List[schemas.DownloaderInfo]]:
         """
         下载器信息
         """
-        return self.run_module("downloader_info")
+        return self.run_module("downloader_info", downloader=downloader)

app/chain/douban.py

@@ -1,10 +1,8 @@
 from typing import Optional, List
 
+from app import schemas
 from app.chain import ChainBase
-from app.core.context import Context
 from app.core.context import MediaInfo
-from app.core.metainfo import MetaInfo
-from app.log import logger
 from app.schemas import MediaType
 
 
@@ -13,39 +11,22 @@ class DoubanChain(ChainBase):
     豆瓣处理链
     """
 
-    def recognize_by_doubanid(self, doubanid: str) -> Optional[Context]:
+    def person_detail(self, person_id: int) -> Optional[schemas.MediaPerson]:
         """
-        根据豆瓣ID识别媒体信息
+        根据人物ID查询豆瓣人物详情
+        :param person_id:  人物ID
         """
-        logger.info(f'开始识别媒体信息，豆瓣ID：{doubanid} ...')
-        # 查询豆瓣信息
-        doubaninfo = self.douban_info(doubanid=doubanid)
-        if not doubaninfo:
-            logger.warn(f'未查询到豆瓣信息，豆瓣ID：{doubanid}')
-            return None
-        return self.recognize_by_doubaninfo(doubaninfo)
+        return self.run_module("douban_person_detail", person_id=person_id)
 
-    def recognize_by_doubaninfo(self, doubaninfo: dict) -> Optional[Context]:
+    def person_credits(self, person_id: int, page: Optional[int] = 1) -> List[MediaInfo]:
         """
-        根据豆瓣信息识别媒体信息
+        根据人物ID查询人物参演作品
+        :param person_id:  人物ID
+        :param page:  页码
         """
-        # 使用原标题匹配
-        meta = MetaInfo(title=doubaninfo.get("original_title") or doubaninfo.get("title"))
-        # 处理类型
-        if isinstance(doubaninfo.get('media_type'), MediaType):
-            meta.type = doubaninfo.get('media_type')
-        else:
-            meta.type = MediaType.MOVIE if doubaninfo.get("type") == "movie" else MediaType.TV
-        # 识别媒体信息
-        mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type)
-        if not mediainfo:
-            logger.warn(f'{meta.name} 未识别到TMDB媒体信息')
-            return Context(meta_info=meta, media_info=MediaInfo(douban_info=doubaninfo))
-        logger.info(f'识别到媒体信息：{mediainfo.type.value} {mediainfo.title_year} {meta.season}')
-        mediainfo.set_douban_info(doubaninfo)
-        return Context(meta_info=meta, media_info=mediainfo)
+        return self.run_module("douban_person_credits", person_id=person_id, page=page)
 
-    def movie_top250(self, page: int = 1, count: int = 30) -> List[dict]:
+    def movie_top250(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取豆瓣电影TOP250
         :param page:  页码
@@ -53,26 +34,26 @@ class DoubanChain(ChainBase):
         """
         return self.run_module("movie_top250", page=page, count=count)
 
-    def movie_showing(self, page: int = 1, count: int = 30) -> List[dict]:
+    def movie_showing(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取正在上映的电影
         """
         return self.run_module("movie_showing", page=page, count=count)
 
-    def tv_weekly_chinese(self, page: int = 1, count: int = 30) -> List[dict]:
+    def tv_weekly_chinese(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取本周中国剧集榜
         """
         return self.run_module("tv_weekly_chinese", page=page, count=count)
 
-    def tv_weekly_global(self, page: int = 1, count: int = 30) -> List[dict]:
+    def tv_weekly_global(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         获取本周全球剧集榜
         """
         return self.run_module("tv_weekly_global", page=page, count=count)
 
     def douban_discover(self, mtype: MediaType, sort: str, tags: str,
-                        page: int = 0, count: int = 30) -> Optional[List[dict]]:
+                        page: Optional[int] = 0, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
         """
         发现豆瓣电影、剧集
         :param mtype:  媒体类型
@@ -84,3 +65,49 @@ class DoubanChain(ChainBase):
         """
         return self.run_module("douban_discover", mtype=mtype, sort=sort, tags=tags,
                                page=page, count=count)
+
+    def tv_animation(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
+        """
+        获取动画剧集
+        """
+        return self.run_module("tv_animation", page=page, count=count)
+
+    def movie_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
+        """
+        获取热门电影
+        """
+        return self.run_module("movie_hot", page=page, count=count)
+
+    def tv_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> Optional[List[MediaInfo]]:
+        """
+        获取热门剧集
+        """
+        return self.run_module("tv_hot", page=page, count=count)
+
+    def movie_credits(self, doubanid: str) -> Optional[List[schemas.MediaPerson]]:
+        """
+        根据TMDBID查询电影演职人员
+        :param doubanid:  豆瓣ID
+        """
+        return self.run_module("douban_movie_credits", doubanid=doubanid)
+
+    def tv_credits(self, doubanid: str) -> Optional[List[schemas.MediaPerson]]:
+        """
+        根据TMDBID查询电视剧演职人员
+        :param doubanid:  豆瓣ID
+        """
+        return self.run_module("douban_tv_credits", doubanid=doubanid)
+
+    def movie_recommend(self, doubanid: str) -> List[MediaInfo]:
+        """
+        根据豆瓣ID查询推荐电影
+        :param doubanid:  豆瓣ID
+        """
+        return self.run_module("douban_movie_recommend", doubanid=doubanid)
+
+    def tv_recommend(self, doubanid: str) -> List[MediaInfo]:
+        """
+        根据豆瓣ID查询推荐电视剧
+        :param doubanid:  豆瓣ID
+        """
+        return self.run_module("douban_tv_recommend", doubanid=doubanid)

app/chain/media.py

@@ -1,38 +1,157 @@
 from pathlib import Path
-from typing import Optional, List, Tuple
+from threading import Lock
+from typing import Optional, List, Tuple, Union
 
+from app import schemas
 from app.chain import ChainBase
+from app.chain.storage import StorageChain
+from app.core.config import settings
 from app.core.context import Context, MediaInfo
+from app.core.event import eventmanager, Event
 from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfo, MetaInfoPath
+from app.db.systemconfig_oper import SystemConfigOper
 from app.log import logger
+from app.schemas import FileItem
+from app.schemas.types import EventType, MediaType, ChainEventType, SystemConfigKey
+from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
 
+recognize_lock = Lock()
+scraping_lock = Lock()
+scraping_files = []
+
 
 class MediaChain(ChainBase):
     """
-    媒体信息处理链
+    媒体信息处理链，单例运行
     """
 
-    def recognize_by_title(self, title: str, subtitle: str = None) -> Optional[Context]:
+    @staticmethod
+    def _get_scraping_switchs() -> dict:
+        """
+        获取刮削开关配置
+        """
+        switchs = SystemConfigOper().get(SystemConfigKey.ScrapingSwitchs) or {}
+        # 默认配置
+        default_switchs = {
+            'movie_nfo': True,          # 电影NFO
+            'movie_poster': True,       # 电影海报
+            'movie_backdrop': True,     # 电影背景图
+            'movie_logo': True,         # 电影Logo
+            'movie_disc': True,         # 电影光盘图
+            'movie_banner': True,       # 电影横幅图
+            'movie_thumb': True,        # 电影缩略图
+            'tv_nfo': True,            # 电视剧NFO
+            'tv_poster': True,         # 电视剧海报  
+            'tv_backdrop': True,       # 电视剧背景图
+            'tv_banner': True,         # 电视剧横幅图
+            'tv_logo': True,           # 电视剧Logo
+            'tv_thumb': True,          # 电视剧缩略图
+            'season_nfo': True,        # 季NFO
+            'season_poster': True,     # 季海报
+            'season_banner': True,     # 季横幅图
+            'season_thumb': True,      # 季缩略图
+            'episode_nfo': True,       # 集NFO
+            'episode_thumb': True      # 集缩略图
+        }
+        # 合并用户配置和默认配置
+        for key, default_value in default_switchs.items():
+            if key not in switchs:
+                switchs[key] = default_value
+        return switchs
+
+    @staticmethod
+    def set_scraping_switchs(switchs: dict) -> bool:
+        """
+        设置刮削开关配置
+        :param switchs: 开关配置字典
+        :return: 是否设置成功
+        """
+        return SystemConfigOper().set(SystemConfigKey.ScrapingSwitchs, switchs)
+
+    def metadata_nfo(self, meta: MetaBase, mediainfo: MediaInfo,
+                     season: Optional[int] = None, episode: Optional[int] = None) -> Optional[str]:
+        """
+        获取NFO文件内容文本
+        :param meta: 元数据
+        :param mediainfo: 媒体信息
+        :param season: 季号
+        :param episode: 集号
+        """
+        return self.run_module("metadata_nfo", meta=meta, mediainfo=mediainfo, season=season, episode=episode)
+
+    def recognize_by_meta(self, metainfo: MetaBase, episode_group: Optional[str] = None) -> Optional[MediaInfo]:
         """
         根据主副标题识别媒体信息
         """
-        logger.info(f'开始识别媒体信息，标题：{title}，副标题：{subtitle} ...')
-        # 识别元数据
-        metainfo = MetaInfo(title, subtitle)
+        title = metainfo.title
         # 识别媒体信息
-        mediainfo: MediaInfo = self.recognize_media(meta=metainfo)
+        mediainfo: MediaInfo = self.recognize_media(meta=metainfo, episode_group=episode_group)
         if not mediainfo:
-            logger.warn(f'{title} 未识别到媒体信息')
-            return Context(meta_info=metainfo)
+            # 尝试使用辅助识别，如果有注册响应事件的话
+            if eventmanager.check(ChainEventType.NameRecognize):
+                logger.info(f'请求辅助识别，标题：{title} ...')
+                mediainfo = self.recognize_help(title=title, org_meta=metainfo)
+            if not mediainfo:
+                logger.warn(f'{title} 未识别到媒体信息')
+                return None
+        # 识别成功
         logger.info(f'{title} 识别到媒体信息：{mediainfo.type.value} {mediainfo.title_year}')
         # 更新媒体图片
         self.obtain_images(mediainfo=mediainfo)
         # 返回上下文
-        return Context(meta_info=metainfo, media_info=mediainfo)
+        return mediainfo
 
-    def recognize_by_path(self, path: str) -> Optional[Context]:
+    def recognize_help(self, title: str, org_meta: MetaBase) -> Optional[MediaInfo]:
+        """
+        请求辅助识别，返回媒体信息
+        :param title: 标题
+        :param org_meta: 原始元数据
+        """
+        # 发送请求事件，等待结果
+        result: Event = eventmanager.send_event(
+            ChainEventType.NameRecognize,
+            {
+                'title': title,
+            }
+        )
+        if not result:
+            return None
+        # 获取返回事件数据
+        event_data = result.event_data or {}
+        logger.info(f'获取到辅助识别结果：{event_data}')
+        # 处理数据格式
+        title, year, season_number, episode_number = None, None, None, None
+        if event_data.get("name"):
+            title = str(event_data["name"]).split("/")[0].strip().replace(".", " ")
+        if event_data.get("year"):
+            year = str(event_data["year"]).split("/")[0].strip()
+        if event_data.get("season") and str(event_data["season"]).isdigit():
+            season_number = int(event_data["season"])
+        if event_data.get("episode") and str(event_data["episode"]).isdigit():
+            episode_number = int(event_data["episode"])
+        if not title:
+            return None
+        if title == 'Unknown':
+            return None
+        if not str(year).isdigit():
+            year = None
+        # 结果赋值
+        if title == org_meta.name and year == org_meta.year:
+            logger.info(f'辅助识别与原始识别结果一致，无需重新识别媒体信息')
+            return None
+        logger.info(f'辅助识别结果与原始识别结果不一致，重新匹配媒体信息 ...')
+        org_meta.name = title
+        org_meta.year = year
+        org_meta.begin_season = season_number
+        org_meta.begin_episode = episode_number
+        if org_meta.begin_season or org_meta.begin_episode:
+            org_meta.type = MediaType.TV
+        # 重新识别
+        return self.recognize_media(meta=org_meta)
+
+    def recognize_by_path(self, path: str, episode_group: Optional[str] = None) -> Optional[Context]:
         """
         根据文件路径识别媒体信息
         """
@@ -41,19 +160,24 @@ class MediaChain(ChainBase):
         # 元数据
         file_meta = MetaInfoPath(file_path)
         # 识别媒体信息
-        mediainfo = self.recognize_media(meta=file_meta)
+        mediainfo = self.recognize_media(meta=file_meta, episode_group=episode_group)
         if not mediainfo:
-            logger.warn(f'{path} 未识别到媒体信息')
-            return Context(meta_info=file_meta)
+            # 尝试使用辅助识别，如果有注册响应事件的话
+            if eventmanager.check(ChainEventType.NameRecognize):
+                logger.info(f'请求辅助识别，标题：{file_path.name} ...')
+                mediainfo = self.recognize_help(title=path, org_meta=file_meta)
+            if not mediainfo:
+                logger.warn(f'{path} 未识别到媒体信息')
+                return Context(meta_info=file_meta)
         logger.info(f'{path} 识别到媒体信息：{mediainfo.type.value} {mediainfo.title_year}')
         # 更新媒体图片
         self.obtain_images(mediainfo=mediainfo)
         # 返回上下文
         return Context(meta_info=file_meta, media_info=mediainfo)
 
-    def search(self, title: str) -> Tuple[MetaBase, List[MediaInfo]]:
+    def search(self, title: str) -> Tuple[Optional[MetaBase], List[MediaInfo]]:
         """
-        搜索媒体信息
+        搜索媒体/人物信息
         :param title: 搜索内容
         :return: 识别元数据，媒体信息列表
         """
@@ -62,8 +186,7 @@ class MediaChain(ChainBase):
         # 识别
         meta = MetaInfo(content)
         if not meta.name:
-            logger.warn(f'{title} 未识别到元数据！')
-            return meta, []
+            meta.cn_name = content
         # 合并信息
         if mtype:
             meta.type = mtype
@@ -82,3 +205,527 @@ class MediaChain(ChainBase):
         logger.info(f"{content} 搜索到 {len(medias)} 条相关媒体信息")
         # 识别的元数据，媒体信息列表
         return meta, medias
+
+    def get_tmdbinfo_by_doubanid(self, doubanid: str, mtype: MediaType = None) -> Optional[dict]:
+        """
+        根据豆瓣ID获取TMDB信息
+        """
+        tmdbinfo = None
+        doubaninfo = self.douban_info(doubanid=doubanid, mtype=mtype)
+        if doubaninfo:
+            # 优先使用原标题匹配
+            if doubaninfo.get("original_title"):
+                meta = MetaInfo(title=doubaninfo.get("title"))
+                meta_org = MetaInfo(title=doubaninfo.get("original_title"))
+            else:
+                meta_org = meta = MetaInfo(title=doubaninfo.get("title"))
+            # 年份
+            if doubaninfo.get("year"):
+                meta.year = doubaninfo.get("year")
+            # 处理类型
+            if isinstance(doubaninfo.get('media_type'), MediaType):
+                meta.type = doubaninfo.get('media_type')
+            else:
+                meta.type = MediaType.MOVIE if doubaninfo.get("type") == "movie" else MediaType.TV
+            # 匹配TMDB信息
+            meta_names = list(dict.fromkeys([k for k in [meta_org.name,
+                                                         meta.cn_name,
+                                                         meta.en_name] if k]))
+            for name in meta_names:
+                tmdbinfo = self.match_tmdbinfo(
+                    name=name,
+                    year=meta.year,
+                    mtype=mtype or meta.type,
+                    season=meta.begin_season
+                )
+                if tmdbinfo:
+                    # 合季季后返回
+                    tmdbinfo['season'] = meta.begin_season
+                    break
+        return tmdbinfo
+
+    def get_tmdbinfo_by_bangumiid(self, bangumiid: int) -> Optional[dict]:
+        """
+        根据BangumiID获取TMDB信息
+        """
+        bangumiinfo = self.bangumi_info(bangumiid=bangumiid)
+        if bangumiinfo:
+            # 优先使用原标题匹配
+            if bangumiinfo.get("name_cn"):
+                meta = MetaInfo(title=bangumiinfo.get("name"))
+                meta_cn = MetaInfo(title=bangumiinfo.get("name_cn"))
+            else:
+                meta_cn = meta = MetaInfo(title=bangumiinfo.get("name"))
+            # 年份
+            release_date = bangumiinfo.get("date") or bangumiinfo.get("air_date")
+            if release_date:
+                year = release_date[:4]
+            else:
+                year = None
+            # 识别TMDB媒体信息
+            meta_names = list(dict.fromkeys([k for k in [meta_cn.name,
+                                                         meta.name] if k]))
+            for name in meta_names:
+                tmdbinfo = self.match_tmdbinfo(
+                    name=name,
+                    year=year,
+                    mtype=MediaType.TV,
+                    season=meta.begin_season
+                )
+                if tmdbinfo:
+                    return tmdbinfo
+        return None
+
+    def get_doubaninfo_by_tmdbid(self, tmdbid: int,
+                                 mtype: MediaType = None, season: Optional[int] = None) -> Optional[dict]:
+        """
+        根据TMDBID获取豆瓣信息
+        """
+        tmdbinfo = self.tmdb_info(tmdbid=tmdbid, mtype=mtype)
+        if tmdbinfo:
+            # 名称
+            name = tmdbinfo.get("title") or tmdbinfo.get("name")
+            # 年份
+            year = None
+            if tmdbinfo.get('release_date'):
+                year = tmdbinfo['release_date'][:4]
+            elif tmdbinfo.get('seasons') and season:
+                for seainfo in tmdbinfo['seasons']:
+                    # 季
+                    season_number = seainfo.get("season_number")
+                    if not season_number:
+                        continue
+                    air_date = seainfo.get("air_date")
+                    if air_date and season_number == season:
+                        year = air_date[:4]
+                        break
+            # IMDBID
+            imdbid = tmdbinfo.get("external_ids", {}).get("imdb_id")
+            return self.match_doubaninfo(
+                name=name,
+                year=year,
+                mtype=mtype,
+                imdbid=imdbid
+            )
+        return None
+
+    def get_doubaninfo_by_bangumiid(self, bangumiid: int) -> Optional[dict]:
+        """
+        根据BangumiID获取豆瓣信息
+        """
+        bangumiinfo = self.bangumi_info(bangumiid=bangumiid)
+        if bangumiinfo:
+            # 优先使用中文标题匹配
+            if bangumiinfo.get("name_cn"):
+                meta = MetaInfo(title=bangumiinfo.get("name_cn"))
+            else:
+                meta = MetaInfo(title=bangumiinfo.get("name"))
+            # 年份
+            release_date = bangumiinfo.get("date") or bangumiinfo.get("air_date")
+            if release_date:
+                year = release_date[:4]
+            else:
+                year = None
+            # 使用名称识别豆瓣媒体信息
+            return self.match_doubaninfo(
+                name=meta.name,
+                year=year,
+                mtype=MediaType.TV,
+                season=meta.begin_season
+            )
+        return None
+
+    @eventmanager.register(EventType.MetadataScrape)
+    def scrape_metadata_event(self, event: Event):
+        """
+        监控手动刮削事件
+        """
+        if not event:
+            return
+        event_data = event.event_data or {}
+        fileitem: FileItem = event_data.get("fileitem")
+        meta: MetaBase = event_data.get("meta")
+        mediainfo: MediaInfo = event_data.get("mediainfo")
+        overwrite = event_data.get("overwrite", False)
+        if not fileitem:
+            return
+        # 刮削锁
+        with scraping_lock:
+            if fileitem.path in scraping_files:
+                return
+            scraping_files.append(fileitem.path)
+        try:
+            # 执行刮削
+            self.scrape_metadata(fileitem=fileitem, meta=meta, mediainfo=mediainfo, overwrite=overwrite)
+        finally:
+            # 释放锁
+            with scraping_lock:
+                scraping_files.remove(fileitem.path)
+
+    def scrape_metadata(self, fileitem: schemas.FileItem,
+                        meta: MetaBase = None, mediainfo: MediaInfo = None,
+                        init_folder: bool = True, parent: schemas.FileItem = None,
+                        overwrite: bool = False):
+        """
+        手动刮削媒体信息
+        :param fileitem: 刮削目录或文件
+        :param meta: 元数据
+        :param mediainfo: 媒体信息
+        :param init_folder: 是否刮削根目录
+        :param parent: 上级目录
+        :param overwrite: 是否覆盖已有文件
+        """
+
+        storagechain = StorageChain()
+
+        def is_bluray_folder(_fileitem: schemas.FileItem) -> bool:
+            """
+            判断是否为原盘目录
+            """
+            if not _fileitem or _fileitem.type != "dir":
+                return False
+            # 蓝光原盘目录必备的文件或文件夹
+            required_files = ['BDMV', 'CERTIFICATE']
+            # 检查目录下是否存在所需文件或文件夹
+            for item in storagechain.list_files(_fileitem):
+                if item.name in required_files:
+                    return True
+            return False
+
+        def __list_files(_fileitem: schemas.FileItem):
+            """
+            列出下级文件
+            """
+            return storagechain.list_files(fileitem=_fileitem)
+
+        def __save_file(_fileitem: schemas.FileItem, _path: Path, _content: Union[bytes, str]):
+            """
+            保存或上传文件
+            :param _fileitem: 关联的媒体文件项
+            :param _path: 元数据文件路径
+            :param _content: 文件内容
+            """
+            if not _fileitem or not _content or not _path:
+                return
+            # 保存文件到临时目录，文件名随机
+            tmp_file = settings.TEMP_PATH / f"{_path.name}.{StringUtils.generate_random_str(10)}"
+            tmp_file.write_bytes(_content)
+            # 获取文件的父目录
+            try:
+                item = storagechain.upload_file(fileitem=_fileitem, path=tmp_file, new_name=_path.name)
+                if item:
+                    logger.info(f"已保存文件：{item.path}")
+                else:
+                    logger.warn(f"文件保存失败：{_path}")
+            finally:
+                if tmp_file.exists():
+                    tmp_file.unlink()
+
+        def __download_image(_url: str) -> Optional[bytes]:
+            """
+            下载图片并保存
+            """
+            try:
+                logger.info(f"正在下载图片：{_url} ...")
+                r = RequestUtils(proxies=settings.PROXY, ua=settings.USER_AGENT).get_res(url=_url)
+                if r:
+                    return r.content
+                else:
+                    logger.info(f"{_url} 图片下载失败，请检查网络连通性！")
+            except Exception as err:
+                logger.error(f"{_url} 图片下载失败：{str(err)}！")
+            return None
+
+        # 当前文件路径
+        filepath = Path(fileitem.path)
+        if fileitem.type == "file" \
+                and (not filepath.suffix or filepath.suffix.lower() not in settings.RMT_MEDIAEXT):
+            return
+        if not meta:
+            meta = MetaInfoPath(filepath)
+        if not mediainfo:
+            mediainfo = self.recognize_by_meta(meta)
+        if not mediainfo:
+            logger.warn(f"{filepath} 无法识别文件媒体信息！")
+            return
+        
+        # 获取刮削开关配置
+        scraping_switchs = self._get_scraping_switchs()
+        logger.info(f"开始刮削：{filepath} ...")
+        if mediainfo.type == MediaType.MOVIE:
+            # 电影
+            if fileitem.type == "file":
+                # 检查电影NFO开关
+                if scraping_switchs.get('movie_nfo', True):
+                    # 是否已存在
+                    nfo_path = filepath.with_suffix(".nfo")
+                    if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                        # 电影文件
+                        movie_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
+                        if movie_nfo:
+                            # 保存或上传nfo文件到上级目录
+                            __save_file(_fileitem=parent, _path=nfo_path, _content=movie_nfo)
+                        else:
+                            logger.warn(f"{filepath.name} nfo文件生成失败！")
+                    else:
+                        logger.info(f"已存在nfo文件：{nfo_path}")
+                else:
+                    logger.info("电影NFO刮削已关闭，跳过")
+            else:
+                # 电影目录
+                if is_bluray_folder(fileitem):
+                    # 原盘目录
+                    if scraping_switchs.get('movie_nfo', True):
+                        nfo_path = filepath / (filepath.name + ".nfo")
+                        if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                            # 生成原盘nfo
+                            movie_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
+                            if movie_nfo:
+                                # 保存或上传nfo文件到当前目录
+                                __save_file(_fileitem=fileitem, _path=nfo_path, _content=movie_nfo)
+                            else:
+                                logger.warn(f"{filepath.name} nfo文件生成失败！")
+                        else:
+                            logger.info(f"已存在nfo文件：{nfo_path}")
+                    else:
+                        logger.info("电影NFO刮削已关闭，跳过")
+                else:
+                    # 处理目录内的文件
+                    files = __list_files(_fileitem=fileitem)
+                    for file in files:
+                        self.scrape_metadata(fileitem=file,
+                                             meta=meta, mediainfo=mediainfo,
+                                             init_folder=False, parent=fileitem,
+                                             overwrite=overwrite)
+                # 生成目录内图片文件
+                if init_folder:
+                    # 图片
+                    image_dict = self.metadata_img(mediainfo=mediainfo)
+                    if image_dict:
+                        for image_name, image_url in image_dict.items():
+                            # 根据图片类型检查开关
+                            if 'poster' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_poster', True)
+                            elif ('backdrop' in image_name.lower()
+                                  or 'fanart' in image_name.lower()
+                                  or 'background' in image_name.lower()):
+                                should_scrape = scraping_switchs.get('movie_backdrop', True)
+                            elif 'logo' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_logo', True)
+                            elif 'disc' in image_name.lower() or 'cdart' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_disc', True)
+                            elif 'banner' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_banner', True)
+                            elif 'thumb' in image_name.lower():
+                                should_scrape = scraping_switchs.get('movie_thumb', True)
+                            else:
+                                should_scrape = True  # 未知类型默认刮削
+                            
+                            if should_scrape:
+                                image_path = filepath.with_name(image_name)
+                                if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
+                                                                               path=image_path):
+                                    # 下载图片
+                                    content = __download_image(image_url)
+                                    # 写入图片到当前目录
+                                    if content:
+                                        __save_file(_fileitem=fileitem, _path=image_path, _content=content)
+                                else:
+                                    logger.info(f"已存在图片文件：{image_path}")
+                            else:
+                                logger.info(f"电影图片刮削已关闭，跳过：{image_name}")
+        else:
+            # 电视剧
+            if fileitem.type == "file":
+                # 重新识别季集
+                file_meta = MetaInfoPath(filepath)
+                if not file_meta.begin_episode:
+                    logger.warn(f"{filepath.name} 无法识别文件集数！")
+                    return
+                file_mediainfo = self.recognize_media(meta=file_meta, tmdbid=mediainfo.tmdb_id,
+                                                      episode_group=mediainfo.episode_group)
+                if not file_mediainfo:
+                    logger.warn(f"{filepath.name} 无法识别文件媒体信息！")
+                    return
+                # 检查集NFO开关
+                if scraping_switchs.get('episode_nfo', True):
+                    # 是否已存在
+                    nfo_path = filepath.with_suffix(".nfo")
+                    if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                        # 获取集的nfo文件
+                        episode_nfo = self.metadata_nfo(meta=file_meta, mediainfo=file_mediainfo,
+                                                        season=file_meta.begin_season,
+                                                        episode=file_meta.begin_episode)
+                        if episode_nfo:
+                            # 保存或上传nfo文件到上级目录
+                            if not parent:
+                                parent = storagechain.get_parent_item(fileitem)
+                            __save_file(_fileitem=parent, _path=nfo_path, _content=episode_nfo)
+                        else:
+                            logger.warn(f"{filepath.name} nfo文件生成失败！")
+                    else:
+                        logger.info(f"已存在nfo文件：{nfo_path}")
+                else:
+                    logger.info("集NFO刮削已关闭，跳过")
+                # 获取集的图片
+                if scraping_switchs.get('episode_thumb', True):
+                    image_dict = self.metadata_img(mediainfo=file_mediainfo,
+                                                   season=file_meta.begin_season, episode=file_meta.begin_episode)
+                    if image_dict:
+                        for episode, image_url in image_dict.items():
+                            image_path = filepath.with_suffix(Path(image_url).suffix)
+                            if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=image_path):
+                                # 下载图片
+                                content = __download_image(image_url)
+                                # 保存图片文件到当前目录
+                                if content:
+                                    if not parent:
+                                        parent = storagechain.get_parent_item(fileitem)
+                                    __save_file(_fileitem=parent, _path=image_path, _content=content)
+                            else:
+                                logger.info(f"已存在图片文件：{image_path}")
+                else:
+                    logger.info("集缩略图刮削已关闭，跳过")
+            else:
+                # 当前为目录，处理目录内的文件
+                files = __list_files(_fileitem=fileitem)
+                for file in files:
+                    self.scrape_metadata(fileitem=file,
+                                         meta=meta, mediainfo=mediainfo,
+                                         parent=fileitem if file.type == "file" else None,
+                                         init_folder=True if file.type == "dir" else False,
+                                         overwrite=overwrite)
+                # 生成目录的nfo和图片
+                if init_folder:
+                    # 识别文件夹名称
+                    season_meta = MetaInfo(filepath.name)
+                    # 当前文件夹为Specials或者SPs时，设置为S0
+                    if filepath.name in settings.RENAME_FORMAT_S0_NAMES:
+                        season_meta.begin_season = 0
+                    if season_meta.begin_season is not None:
+                        # 检查季NFO开关
+                        if scraping_switchs.get('season_nfo', True):
+                            # 是否已存在
+                            nfo_path = filepath / "season.nfo"
+                            if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                                # 当前目录有季号，生成季nfo
+                                season_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo,
+                                                               season=season_meta.begin_season)
+                                if season_nfo:
+                                    # 写入nfo到根目录
+                                    __save_file(_fileitem=fileitem, _path=nfo_path, _content=season_nfo)
+                                else:
+                                    logger.warn(f"无法生成电视剧季nfo文件：{meta.name}")
+                            else:
+                                logger.info(f"已存在nfo文件：{nfo_path}")
+                        else:
+                            logger.info("季NFO刮削已关闭，跳过")
+                        # TMDB季poster图片
+                        if scraping_switchs.get('season_poster', True):
+                            image_dict = self.metadata_img(mediainfo=mediainfo, season=season_meta.begin_season)
+                            if image_dict:
+                                for image_name, image_url in image_dict.items():
+                                    image_path = filepath.with_name(image_name)
+                                    if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
+                                                                                   path=image_path):
+                                        # 下载图片
+                                        content = __download_image(image_url)
+                                        # 保存图片文件到剧集目录
+                                        if content:
+                                            if not parent:
+                                                parent = storagechain.get_parent_item(fileitem)
+                                            __save_file(_fileitem=parent, _path=image_path, _content=content)
+                                    else:
+                                        logger.info(f"已存在图片文件：{image_path}")
+                        else:
+                            logger.info("季海报刮削已关闭，跳过")
+                        # 额外fanart季图片：poster thumb banner
+                        image_dict = self.metadata_img(mediainfo=mediainfo)
+                        if image_dict:
+                            for image_name, image_url in image_dict.items():
+                                if image_name.startswith("season"):
+                                    # 根据季图片类型检查开关
+                                    if 'poster' in image_name.lower():
+                                        should_scrape = scraping_switchs.get('season_poster', True)
+                                    elif 'banner' in image_name.lower():
+                                        should_scrape = scraping_switchs.get('season_banner', True)
+                                    elif 'thumb' in image_name.lower():
+                                        should_scrape = scraping_switchs.get('season_thumb', True)
+                                    else:
+                                        should_scrape = True  # 未知类型默认刮削
+                                    
+                                    if should_scrape:
+                                        image_path = filepath.with_name(image_name)
+                                        # 只下载当前刮削季的图片
+                                        image_season = "00" if "specials" in image_name else image_name[6:8]
+                                        if image_season != str(season_meta.begin_season).rjust(2, '0'):
+                                            logger.info(f"当前刮削季为：{season_meta.begin_season}，跳过文件：{image_path}")
+                                            continue
+                                        if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
+                                                                                       path=image_path):
+                                            # 下载图片
+                                            content = __download_image(image_url)
+                                            # 保存图片文件到当前目录
+                                            if content:
+                                                if not parent:
+                                                    parent = storagechain.get_parent_item(fileitem)
+                                                __save_file(_fileitem=parent, _path=image_path, _content=content)
+                                        else:
+                                            logger.info(f"已存在图片文件：{image_path}")
+                                    else:
+                                        logger.info(f"季图片刮削已关闭，跳过：{image_name}")
+                    # 判断当前目录是不是剧集根目录
+                    if not season_meta.season:
+                        # 检查电视剧NFO开关
+                        if scraping_switchs.get('tv_nfo', True):
+                            # 是否已存在
+                            nfo_path = filepath / "tvshow.nfo"
+                            if overwrite or not storagechain.get_file_item(storage=fileitem.storage, path=nfo_path):
+                                # 当前目录有名称，生成tvshow nfo 和 tv图片
+                                tv_nfo = self.metadata_nfo(meta=meta, mediainfo=mediainfo)
+                                if tv_nfo:
+                                    # 写入tvshow nfo到根目录
+                                    __save_file(_fileitem=fileitem, _path=nfo_path, _content=tv_nfo)
+                                else:
+                                    logger.warn(f"无法生成电视剧nfo文件：{meta.name}")
+                            else:
+                                logger.info(f"已存在nfo文件：{nfo_path}")
+                        else:
+                            logger.info("电视剧NFO刮削已关闭，跳过")
+                        # 生成目录图片
+                        image_dict = self.metadata_img(mediainfo=mediainfo)
+                        if image_dict:
+                            for image_name, image_url in image_dict.items():
+                                # 不下载季图片
+                                if image_name.startswith("season"):
+                                    continue
+                                # 根据电视剧图片类型检查开关
+                                if 'poster' in image_name.lower():
+                                    should_scrape = scraping_switchs.get('tv_poster', True)
+                                elif ('backdrop' in image_name.lower()
+                                      or 'fanart' in image_name.lower()
+                                      or 'background' in image_name.lower()):
+                                    should_scrape = scraping_switchs.get('tv_backdrop', True)
+                                elif 'banner' in image_name.lower():
+                                    should_scrape = scraping_switchs.get('tv_banner', True)
+                                elif 'logo' in image_name.lower():
+                                    should_scrape = scraping_switchs.get('tv_logo', True)
+                                elif 'thumb' in image_name.lower():
+                                    should_scrape = scraping_switchs.get('tv_thumb', True)
+                                else:
+                                    should_scrape = True  # 未知类型默认刮削
+                                
+                                if should_scrape:
+                                    image_path = filepath / image_name
+                                    if overwrite or not storagechain.get_file_item(storage=fileitem.storage,
+                                                                                   path=image_path):
+                                        # 下载图片
+                                        content = __download_image(image_url)
+                                        # 保存图片文件到当前目录
+                                        if content:
+                                            __save_file(_fileitem=fileitem, _path=image_path, _content=content)
+                                    else:
+                                        logger.info(f"已存在图片文件：{image_path}")
+                                else:
+                                    logger.info(f"电视剧图片刮削已关闭，跳过：{image_name}")
+        logger.info(f"{filepath.name} 刮削完成")

app/chain/mediaserver.py

@@ -1,15 +1,12 @@
-import json
 import threading
-from typing import List, Union, Generator
+from typing import List, Union, Optional, Generator, Any
 
-from sqlalchemy.orm import Session
-
-from app import schemas
 from app.chain import ChainBase
-from app.core.config import settings
-from app.db import SessionFactory
+from app.core.config import global_vars
 from app.db.mediaserver_oper import MediaServerOper
+from app.helper.service import ServiceConfigHelper
 from app.log import logger
+from app.schemas import MediaServerLibrary, MediaServerItem, MediaServerSeasonInfo, MediaServerPlayItem
 
 lock = threading.Lock()
 
@@ -19,85 +16,162 @@ class MediaServerChain(ChainBase):
     媒体服务器处理链
     """
 
-    def __init__(self, db: Session = None):
-        super().__init__(db)
-
-    def librarys(self, server: str) -> List[schemas.MediaServerLibrary]:
+    def librarys(self, server: str, username: Optional[str] = None,
+                 hidden: bool = False) -> List[MediaServerLibrary]:
         """
         获取媒体服务器所有媒体库
         """
-        return self.run_module("mediaserver_librarys", server=server)
+        return self.run_module("mediaserver_librarys", server=server, username=username, hidden=hidden)
 
-    def items(self, server: str, library_id: Union[str, int]) -> List[schemas.MediaServerItem]:
+    def items(self, server: str, library_id: Union[str, int],
+              start_index: Optional[int] = 0, limit: Optional[int] = -1) -> Generator[Any, None, None]:
         """
-        获取媒体服务器所有项目
-        """
-        return self.run_module("mediaserver_items", server=server, library_id=library_id)
+        获取媒体服务器项目列表，支持分页和不分页逻辑，默认不分页获取所有数据
 
-    def iteminfo(self, server: str, item_id: Union[str, int]) -> schemas.MediaServerItem:
+        :param server: 媒体服务器名称
+        :param library_id: 媒体库ID，用于标识要获取的媒体库
+        :param start_index: 起始索引，用于分页获取数据。默认为 0，即从第一个项目开始获取
+        :param limit: 每次请求的最大项目数，用于分页。如果为 None 或 -1，则表示一次性获取所有数据，默认为 -1
+
+        :return: 返回一个生成器对象，用于逐步获取媒体服务器中的项目
+
+        说明：
+        - 特别注意的是，这里使用yield from返回迭代器，避免同时使用return与yield导致Python生成器解析异常
+        - 如果 `limit` 为 None 或 -1 时，表示一次性获取所有数据，分页处理将不再生效
+        - 在这种情况下，内存消耗可能会较大，特别是在数据量非常大的场景下
+        - 如果未来评估结果显示，不分页场景下的内存消耗远大于分页处理时的网络请求开销，可以考虑在此方法中实现自分页的处理
+        - 即通过 `while` 循环在上层进行分页控制，逐步获取所有数据，避免内存爆炸，当前该逻辑由具体实例来实现不分页的处理
+        - Plex 实际上已默认支持内部分页处理，Jellyfin 与 Emby 获取数据时存在内部过滤场景，如排除合集等，分页数据可能是错误的
+        if limit is not None and limit != -1:
+            yield from self.run_module("mediaserver_items", server=server, library_id=library_id,
+                                   start_index=start_index, limit=limit)
+        else:
+            # 自分页逻辑，通过循环逐步获取所有数据
+            page_size = 10
+            while True:
+                data_generator = self.run_module("mediaserver_items", server=server, library_id=library_id,
+                                                 start_index=start_index, limit=page_size)
+                if not data_generator:
+                    break
+                count = 0
+                for item in data_generator:
+                    if item:
+                        count += 1
+                        yield item
+                if count < page_size:
+                    break
+                start_index += page_size
+        """
+        yield from self.run_module("mediaserver_items", server=server, library_id=library_id,
+                                   start_index=start_index, limit=limit)
+
+    def iteminfo(self, server: str, item_id: Union[str, int]) -> MediaServerItem:
         """
         获取媒体服务器项目信息
         """
         return self.run_module("mediaserver_iteminfo", server=server, item_id=item_id)
 
-    def episodes(self, server: str, item_id: Union[str, int]) -> List[schemas.MediaServerSeasonInfo]:
+    def episodes(self, server: str, item_id: Union[str, int]) -> List[MediaServerSeasonInfo]:
         """
         获取媒体服务器剧集信息
         """
         return self.run_module("mediaserver_tv_episodes", server=server, item_id=item_id)
 
+    def playing(self, server: str, count: Optional[int] = 20,
+                username: Optional[str] = None) -> List[MediaServerPlayItem]:
+        """
+        获取媒体服务器正在播放信息
+        """
+        return self.run_module("mediaserver_playing", count=count, server=server, username=username)
+
+    def latest(self, server: str, count: Optional[int] = 20,
+               username: Optional[str] = None) -> List[MediaServerPlayItem]:
+        """
+        获取媒体服务器最新入库条目
+        """
+        return self.run_module("mediaserver_latest", count=count, server=server, username=username)
+
+    def get_latest_wallpapers(self, server: Optional[str] = None, count: Optional[int] = 10,
+                              remote: bool = True, username: Optional[str] = None) -> List[str]:
+        """
+        获取最新最新入库条目海报作为壁纸，缓存1小时
+        """
+        return self.run_module("mediaserver_latest_images", server=server, count=count,
+                               remote=remote, username=username)
+
+    def get_latest_wallpaper(self, server: Optional[str] = None,
+                             remote: bool = True, username: Optional[str] = None) -> Optional[str]:
+        """
+        获取最新最新入库条目海报作为壁纸，缓存1小时
+        """
+        wallpapers = self.get_latest_wallpapers(server=server, count=1, remote=remote, username=username)
+        return wallpapers[0] if wallpapers else None
+
+    def get_play_url(self, server: str, item_id: Union[str, int]) -> Optional[str]:
+        """
+        获取播放地址
+        """
+        return self.run_module("mediaserver_play_url", server=server, item_id=item_id)
+
     def sync(self):
         """
         同步媒体库所有数据到本地数据库
         """
+        # 设置的媒体服务器
+        mediaservers = ServiceConfigHelper.get_mediaserver_configs()
+        if not mediaservers:
+            return
         with lock:
-            # 媒体服务器同步使用独立的会话
-            _db = SessionFactory()
-            _dbOper = MediaServerOper(_db)
             # 汇总统计
             total_count = 0
             # 清空登记薄
-            _dbOper.empty(server=settings.MEDIASERVER)
-            # 同步黑名单
-            sync_blacklist = settings.MEDIASERVER_SYNC_BLACKLIST.split(
-                ",") if settings.MEDIASERVER_SYNC_BLACKLIST else []
-            # 设置的媒体服务器
-            if not settings.MEDIASERVER:
-                return
-            mediaservers = settings.MEDIASERVER.split(",")
+            dboper = MediaServerOper()
+            dboper.empty()
             # 遍历媒体服务器
             for mediaserver in mediaservers:
-                logger.info(f"开始同步媒体库 {mediaserver} 的数据 ...")
-                for library in self.librarys(mediaserver):
-                    # 同步黑名单 跳过
-                    if library.name in sync_blacklist:
+                if not mediaserver:
+                    continue
+                logger.info(f"正在准备同步媒体服务器 {mediaserver.name} 的数据")
+                if not mediaserver.enabled:
+                    logger.info(f"媒体服务器 {mediaserver.name} 未启用，跳过")
+                    continue
+                server_name = mediaserver.name
+                sync_libraries = mediaserver.sync_libraries or []
+                logger.info(f"开始同步媒体服务器 {server_name} 的数据 ...")
+                libraries = self.librarys(server_name)
+                if not libraries:
+                    logger.info(f"没有获取到媒体服务器 {server_name} 的媒体库，跳过")
+                    continue
+                for library in libraries:
+                    if sync_libraries \
+                            and "all" not in sync_libraries \
+                            and str(library.id) not in sync_libraries:
+                        logger.info(f"{library.name} 未在 {server_name} 同步媒体库列表中，跳过")
                         continue
-                    logger.info(f"正在同步 {mediaserver} 媒体库 {library.name} ...")
+                    logger.info(f"正在同步 {server_name} 媒体库 {library.name} ...")
                     library_count = 0
-                    for item in self.items(mediaserver, library.id):
-                        if not item:
-                            continue
-                        if not item.item_id:
+                    for item in self.items(server=server_name, library_id=library.id):
+                        if global_vars.is_system_stopped:
+                            return
+                        if not item or not item.item_id:
                             continue
+                        logger.debug(f"正在同步 {item.title} ...")
                         # 计数
                         library_count += 1
                         seasoninfo = {}
                         # 类型
-                        item_type = "电视剧" if item.item_type in ['Series', 'show'] else "电影"
+                        item_type = "电视剧" if item.item_type in ["Series", "show"] else "电影"
                         if item_type == "电视剧":
                             # 查询剧集信息
-                            espisodes_info = self.episodes(mediaserver, item.item_id) or []
+                            espisodes_info = self.episodes(server_name, item.item_id) or []
                             for episode in espisodes_info:
                                 seasoninfo[episode.season] = episode.episodes
                         # 插入数据
                         item_dict = item.dict()
-                        item_dict['seasoninfo'] = json.dumps(seasoninfo)
-                        item_dict['item_type'] = item_type
-                        _dbOper.add(**item_dict)
-                    logger.info(f"{mediaserver} 媒体库 {library.name} 同步完成，共同步数量：{library_count}")
+                        item_dict["seasoninfo"] = seasoninfo
+                        item_dict["item_type"] = item_type
+                        dboper.add(**item_dict)
+                    logger.info(f"{server_name} 媒体库 {library.name} 同步完成，共同步数量：{library_count}")
                     # 总数累加
                     total_count += library_count
-            # 关闭数据库连接
-            if _db:
-                _db.close()
-            logger.info("【MediaServer】媒体库数据同步完成，同步数量：%s" % total_count)
+                logger.info(f"媒体服务器 {server_name} 数据同步完成，总同步数量：{total_count}")

app/chain/recommend.py

@@ -0,0 +1,312 @@
+import io
+import tempfile
+from pathlib import Path
+from typing import List, Optional
+
+import pillow_avif  # noqa 用于自动注册AVIF支持
+from PIL import Image
+
+from app.chain import ChainBase
+from app.chain.bangumi import BangumiChain
+from app.chain.douban import DoubanChain
+from app.chain.tmdb import TmdbChain
+from app.core.cache import cache_backend, cached
+from app.core.config import settings, global_vars
+from app.log import logger
+from app.schemas import MediaType
+from app.utils.common import log_execution_time
+from app.utils.http import RequestUtils
+from app.utils.security import SecurityUtils
+from app.utils.singleton import Singleton
+
+# 推荐相关的专用缓存
+recommend_ttl = 24 * 3600
+recommend_cache_region = "recommend"
+
+
+class RecommendChain(ChainBase, metaclass=Singleton):
+    """
+    推荐处理链，单例运行
+    """
+
+    # 推荐数据的缓存页数
+    cache_max_pages = 5
+
+    def refresh_recommend(self):
+        """
+        刷新推荐
+        """
+        logger.debug("Starting to refresh Recommend data.")
+        cache_backend.clear(region=recommend_cache_region)
+        logger.debug("Recommend Cache has been cleared.")
+
+        # 推荐来源方法
+        recommend_methods = [
+            self.tmdb_movies,
+            self.tmdb_tvs,
+            self.tmdb_trending,
+            self.bangumi_calendar,
+            self.douban_movie_showing,
+            self.douban_movies,
+            self.douban_tvs,
+            self.douban_movie_top250,
+            self.douban_tv_weekly_chinese,
+            self.douban_tv_weekly_global,
+            self.douban_tv_animation,
+            self.douban_movie_hot,
+            self.douban_tv_hot,
+        ]
+
+        # 缓存并刷新所有推荐数据
+        recommends = []
+        # 记录哪些方法已完成
+        methods_finished = set()
+        # 这里避免区间内连续调用相同来源，因此遍历方案为每页遍历所有推荐来源，再进行页数遍历
+        for page in range(1, self.cache_max_pages + 1):
+            for method in recommend_methods:
+                if global_vars.is_system_stopped:
+                    return
+                if method in methods_finished:
+                    continue
+                logger.debug(f"Fetch {method.__name__} data for page {page}.")
+                data = method(page=page)
+                if not data:
+                    logger.debug("All recommendation methods have finished fetching data. Ending pagination early.")
+                    methods_finished.add(method)
+                    continue
+                recommends.extend(data)
+            # 如果所有方法都已经完成，提前结束循环
+            if len(methods_finished) == len(recommend_methods):
+                break
+
+        # 缓存收集到的海报
+        self.__cache_posters(recommends)
+        logger.debug("Recommend data refresh completed.")
+
+    def __cache_posters(self, datas: List[dict]):
+        """
+        提取 poster_path 并缓存图片
+        :param datas: 数据列表
+        """
+        if not settings.GLOBAL_IMAGE_CACHE:
+            return
+
+        for data in datas:
+            if global_vars.is_system_stopped:
+                return
+            poster_path = data.get("poster_path")
+            if poster_path:
+                poster_url = poster_path.replace("original", "w500")
+                logger.debug(f"Caching poster image: {poster_url}")
+                self.__fetch_and_save_image(poster_url)
+
+    @staticmethod
+    def __fetch_and_save_image(url: str):
+        """
+        请求并保存图片
+        :param url: 图片路径
+        """
+        if not settings.GLOBAL_IMAGE_CACHE or not url:
+            return
+
+        # 生成缓存路径
+        sanitized_path = SecurityUtils.sanitize_url_path(url)
+        cache_path = settings.CACHE_PATH / "images" / sanitized_path
+
+        # 没有文件类型，则添加后缀，在恶意文件类型和实际需求下的折衷选择
+        if not cache_path.suffix:
+            cache_path = cache_path.with_suffix(".jpg")
+
+        # 确保缓存路径和文件类型合法
+        if not SecurityUtils.is_safe_path(settings.CACHE_PATH, cache_path, settings.SECURITY_IMAGE_SUFFIXES):
+            logger.debug(f"Invalid cache path or file type for URL: {url}, sanitized path: {sanitized_path}")
+            return
+
+        # 本地存在缓存图片，则直接跳过
+        if cache_path.exists():
+            logger.debug(f"Cache hit: Image already exists at {cache_path}")
+            return
+
+        # 请求远程图片
+        referer = "https://movie.douban.com/" if "doubanio.com" in url else None
+        proxies = settings.PROXY if not referer else None
+        response = RequestUtils(ua=settings.USER_AGENT, proxies=proxies, referer=referer).get_res(url=url)
+        if not response:
+            logger.debug(f"Empty response for URL: {url}")
+            return
+
+        # 验证下载的内容是否为有效图片
+        try:
+            Image.open(io.BytesIO(response.content)).verify()
+        except Exception as e:
+            logger.debug(f"Invalid image format for URL {url}: {e}")
+            return
+
+        if not cache_path:
+            return
+
+        try:
+            if not cache_path.parent.exists():
+                cache_path.parent.mkdir(parents=True, exist_ok=True)
+            with tempfile.NamedTemporaryFile(dir=cache_path.parent, delete=False) as tmp_file:
+                tmp_file.write(response.content)
+                temp_path = Path(tmp_file.name)
+            temp_path.replace(cache_path)
+            logger.debug(f"Successfully cached image at {cache_path} for URL: {url}")
+        except Exception as e:
+            logger.debug(f"Failed to write cache file {cache_path} for URL {url}: {e}")
+
+    @log_execution_time(logger=logger)
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def tmdb_movies(self, sort_by: Optional[str] = "popularity.desc",
+                    with_genres: Optional[str] = "",
+                    with_original_language: Optional[str] = "",
+                    with_keywords: Optional[str] = "",
+                    with_watch_providers: Optional[str] = "",
+                    vote_average: Optional[float] = 0.0,
+                    vote_count: Optional[int] = 0,
+                    release_date: Optional[str] = "",
+                    page: Optional[int] = 1) -> List[dict]:
+        """
+        TMDB热门电影
+        """
+        movies = TmdbChain().tmdb_discover(mtype=MediaType.MOVIE,
+                                           sort_by=sort_by,
+                                           with_genres=with_genres,
+                                           with_original_language=with_original_language,
+                                           with_keywords=with_keywords,
+                                           with_watch_providers=with_watch_providers,
+                                           vote_average=vote_average,
+                                           vote_count=vote_count,
+                                           release_date=release_date,
+                                           page=page)
+        return [movie.to_dict() for movie in movies] if movies else []
+
+    @log_execution_time(logger=logger)
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def tmdb_tvs(self, sort_by: Optional[str] = "popularity.desc",
+                 with_genres: Optional[str] = "",
+                 with_original_language: Optional[str] = "zh|en|ja|ko",
+                 with_keywords: Optional[str] = "",
+                 with_watch_providers: Optional[str] = "",
+                 vote_average: Optional[float] = 0.0,
+                 vote_count: Optional[int] = 0,
+                 release_date: Optional[str] = "",
+                 page: Optional[int] = 1) -> List[dict]:
+        """
+        TMDB热门电视剧
+        """
+        tvs = TmdbChain().tmdb_discover(mtype=MediaType.TV,
+                                        sort_by=sort_by,
+                                        with_genres=with_genres,
+                                        with_original_language=with_original_language,
+                                        with_keywords=with_keywords,
+                                        with_watch_providers=with_watch_providers,
+                                        vote_average=vote_average,
+                                        vote_count=vote_count,
+                                        release_date=release_date,
+                                        page=page)
+        return [tv.to_dict() for tv in tvs] if tvs else []
+
+    @log_execution_time(logger=logger)
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def tmdb_trending(self, page: Optional[int] = 1) -> List[dict]:
+        """
+        TMDB流行趋势
+        """
+        infos = TmdbChain().tmdb_trending(page=page)
+        return [info.to_dict() for info in infos] if infos else []
+
+    @log_execution_time(logger=logger)
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def bangumi_calendar(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
+        """
+        Bangumi每日放送
+        """
+        medias = BangumiChain().calendar()
+        return [media.to_dict() for media in medias[(page - 1) * count: page * count]] if medias else []
+
+    @log_execution_time(logger=logger)
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_movie_showing(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
+        """
+        豆瓣正在热映
+        """
+        movies = DoubanChain().movie_showing(page=page, count=count)
+        return [media.to_dict() for media in movies] if movies else []
+
+    @log_execution_time(logger=logger)
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_movies(self, sort: Optional[str] = "R", tags: Optional[str] = "",
+                      page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
+        """
+        豆瓣最新电影
+        """
+        movies = DoubanChain().douban_discover(mtype=MediaType.MOVIE,
+                                               sort=sort, tags=tags, page=page, count=count)
+        return [media.to_dict() for media in movies] if movies else []
+
+    @log_execution_time(logger=logger)
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_tvs(self, sort: Optional[str] = "R", tags: Optional[str] = "",
+                   page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
+        """
+        豆瓣最新电视剧
+        """
+        tvs = DoubanChain().douban_discover(mtype=MediaType.TV,
+                                            sort=sort, tags=tags, page=page, count=count)
+        return [media.to_dict() for media in tvs] if tvs else []
+
+    @log_execution_time(logger=logger)
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_movie_top250(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
+        """
+        豆瓣电影TOP250
+        """
+        movies = DoubanChain().movie_top250(page=page, count=count)
+        return [media.to_dict() for media in movies] if movies else []
+
+    @log_execution_time(logger=logger)
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_tv_weekly_chinese(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
+        """
+        豆瓣国产剧集榜
+        """
+        tvs = DoubanChain().tv_weekly_chinese(page=page, count=count)
+        return [media.to_dict() for media in tvs] if tvs else []
+
+    @log_execution_time(logger=logger)
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_tv_weekly_global(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
+        """
+        豆瓣全球剧集榜
+        """
+        tvs = DoubanChain().tv_weekly_global(page=page, count=count)
+        return [media.to_dict() for media in tvs] if tvs else []
+
+    @log_execution_time(logger=logger)
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_tv_animation(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
+        """
+        豆瓣热门动漫
+        """
+        tvs = DoubanChain().tv_animation(page=page, count=count)
+        return [media.to_dict() for media in tvs] if tvs else []
+
+    @log_execution_time(logger=logger)
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_movie_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
+        """
+        豆瓣热门电影
+        """
+        movies = DoubanChain().movie_hot(page=page, count=count)
+        return [media.to_dict() for media in movies] if movies else []
+
+    @log_execution_time(logger=logger)
+    @cached(ttl=recommend_ttl, region=recommend_cache_region)
+    def douban_tv_hot(self, page: Optional[int] = 1, count: Optional[int] = 30) -> List[dict]:
+        """
+        豆瓣热门电视剧
+        """
+        tvs = DoubanChain().tv_hot(page=page, count=count)
+        return [media.to_dict() for media in tvs] if tvs else []

app/chain/search.py

@@ -1,15 +1,15 @@
 import pickle
-import re
+import traceback
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime
 from typing import Dict
 from typing import List, Optional
 
-from sqlalchemy.orm import Session
-
 from app.chain import ChainBase
+from app.core.config import global_vars
 from app.core.context import Context
 from app.core.context import MediaInfo, TorrentInfo
+from app.core.event import eventmanager, Event
 from app.core.metainfo import MetaInfo
 from app.db.systemconfig_oper import SystemConfigOper
 from app.helper.progress import ProgressHelper
@@ -17,8 +17,7 @@ from app.helper.sites import SitesHelper
 from app.helper.torrent import TorrentHelper
 from app.log import logger
 from app.schemas import NotExistMediaInfo
-from app.schemas.types import MediaType, ProgressKey, SystemConfigKey
-from app.utils.string import StringUtils
+from app.schemas.types import MediaType, ProgressKey, SystemConfigKey, EventType
 
 
 class SearchChain(ChainBase):
@@ -26,96 +25,146 @@ class SearchChain(ChainBase):
     站点资源搜索处理链
     """
 
-    def __init__(self, db: Session = None):
-        super().__init__(db)
-        self.siteshelper = SitesHelper()
-        self.progress = ProgressHelper()
-        self.systemconfig = SystemConfigOper()
-        self.torrenthelper = TorrentHelper()
+    __result_temp_file = "__search_result__"
 
-    def search_by_tmdbid(self, tmdbid: int, mtype: MediaType = None, area: str = "title") -> List[Context]:
+    def search_by_id(self, tmdbid: Optional[int] = None, doubanid: Optional[str] = None,
+                     mtype: MediaType = None, area: Optional[str] = "title", season: Optional[int] = None,
+                     sites: List[int] = None, cache_local: bool = False) -> List[Context]:
         """
-        根据TMDB ID搜索资源，精确匹配，但不不过滤本地存在的资源
+        根据TMDBID/豆瓣ID搜索资源，精确匹配，不过滤本地存在的资源
         :param tmdbid: TMDB ID
+        :param doubanid: 豆瓣 ID
         :param mtype: 媒体，电影 or 电视剧
         :param area: 搜索范围，title or imdbid
+        :param season: 季数
+        :param sites: 站点ID列表
+        :param cache_local: 是否缓存到本地
         """
-        mediainfo = self.recognize_media(tmdbid=tmdbid, mtype=mtype)
+        mediainfo = self.recognize_media(tmdbid=tmdbid, doubanid=doubanid, mtype=mtype)
         if not mediainfo:
             logger.error(f'{tmdbid} 媒体信息识别失败！')
             return []
-        results = self.process(mediainfo=mediainfo, area=area)
-        # 保存眲结果
-        bytes_results = pickle.dumps(results)
-        self.systemconfig.set(SystemConfigKey.SearchResults, bytes_results)
+        no_exists = None
+        if season:
+            no_exists = {
+                tmdbid or doubanid: {
+                    season: NotExistMediaInfo(episodes=[])
+                }
+            }
+        results = self.process(mediainfo=mediainfo, sites=sites, area=area, no_exists=no_exists)
+        # 保存到本地文件
+        if cache_local:
+            self.save_cache(pickle.dumps(results), self.__result_temp_file)
         return results
 
-    def search_by_title(self, title: str, page: int = 0, site: int = None) -> List[TorrentInfo]:
+    def search_by_title(self, title: str, page: Optional[int] = 0,
+                        sites: List[int] = None, cache_local: Optional[bool] = False) -> List[Context]:
         """
         根据标题搜索资源，不识别不过滤，直接返回站点内容
         :param title: 标题，为空时返回所有站点首页内容
         :param page: 页码
-        :param site: 站点ID
+        :param sites: 站点ID列表
+        :param cache_local: 是否缓存到本地
         """
         if title:
             logger.info(f'开始搜索资源，关键词：{title} ...')
         else:
-            logger.info(f'开始浏览资源，站点：{site} ...')
+            logger.info(f'开始浏览资源，站点：{sites} ...')
         # 搜索
-        return self.__search_all_sites(keywords=[title], sites=[site] if site else None, page=page) or []
+        torrents = self.__search_all_sites(keywords=[title], sites=sites, page=page) or []
+        if not torrents:
+            logger.warn(f'{title} 未搜索到资源')
+            return []
+        # 组装上下文
+        contexts = [Context(meta_info=MetaInfo(title=torrent.title, subtitle=torrent.description),
+                            torrent_info=torrent) for torrent in torrents]
+        # 保存到本地文件
+        if cache_local:
+            self.save_cache(pickle.dumps(contexts), self.__result_temp_file)
+        return contexts
 
     def last_search_results(self) -> List[Context]:
         """
         获取上次搜索结果
         """
-        results = self.systemconfig.get(SystemConfigKey.SearchResults)
-        if not results:
+        # 读取本地文件缓存
+        content = self.load_cache(self.__result_temp_file)
+        if not content:
             return []
         try:
-            return pickle.loads(results)
+            return pickle.loads(content)
         except Exception as e:
-            print(str(e))
+            logger.error(f'加载搜索结果失败：{str(e)} - {traceback.format_exc()}')
             return []
 
     def process(self, mediainfo: MediaInfo,
-                keyword: str = None,
+                keyword: Optional[str] = None,
                 no_exists: Dict[int, Dict[int, NotExistMediaInfo]] = None,
                 sites: List[int] = None,
-                priority_rule: str = None,
-                filter_rule: Dict[str, str] = None,
-                area: str = "title") -> List[Context]:
+                rule_groups: List[str] = None,
+                area: Optional[str] = "title",
+                custom_words: List[str] = None,
+                filter_params: Dict[str, str] = None) -> List[Context]:
         """
         根据媒体信息搜索种子资源，精确匹配，应用过滤规则，同时根据no_exists过滤本地已存在的资源
         :param mediainfo: 媒体信息
         :param keyword: 搜索关键词
         :param no_exists: 缺失的媒体信息
         :param sites: 站点ID列表，为空时搜索所有站点
-        :param priority_rule: 优先级规则，为空时使用搜索优先级规则
-        :param filter_rule: 过滤规则，为空是使用默认过滤规则
+        :param rule_groups: 过滤规则组名称列表
         :param area: 搜索范围，title or imdbid
+        :param custom_words: 自定义识别词列表
+        :param filter_params: 过滤参数
         """
+
+        def __do_filter(torrent_list: List[TorrentInfo]) -> List[TorrentInfo]:
+            """
+            执行优先级过滤
+            """
+            return self.filter_torrents(rule_groups=rule_groups,
+                                        torrent_list=torrent_list,
+                                        mediainfo=mediainfo) or []
+
+        # 豆瓣标题处理
+        if not mediainfo.tmdb_id:
+            meta = MetaInfo(title=mediainfo.title)
+            mediainfo.title = meta.name
+            mediainfo.season = meta.begin_season
         logger.info(f'开始搜索资源，关键词：{keyword or mediainfo.title} ...')
+
         # 补充媒体信息
         if not mediainfo.names:
             mediainfo: MediaInfo = self.recognize_media(mtype=mediainfo.type,
-                                                        tmdbid=mediainfo.tmdb_id)
+                                                        tmdbid=mediainfo.tmdb_id,
+                                                        doubanid=mediainfo.douban_id)
             if not mediainfo:
                 logger.error(f'媒体信息识别失败！')
                 return []
+
         # 缺失的季集
-        if no_exists and no_exists.get(mediainfo.tmdb_id):
+        mediakey = mediainfo.tmdb_id or mediainfo.douban_id
+        if no_exists and no_exists.get(mediakey):
             # 过滤剧集
             season_episodes = {sea: info.episodes
-                               for sea, info in no_exists[mediainfo.tmdb_id].items()}
+                               for sea, info in no_exists[mediakey].items()}
+        elif mediainfo.season:
+            # 豆瓣只搜索当前季
+            season_episodes = {mediainfo.season: []}
         else:
             season_episodes = None
+
         # 搜索关键词
         if keyword:
             keywords = [keyword]
-        elif mediainfo.original_title and mediainfo.title != mediainfo.original_title:
-            keywords = [mediainfo.title, mediainfo.original_title]
         else:
-            keywords = [mediainfo.title]
+            # 去重去空，但要保持顺序
+            keywords = list(dict.fromkeys([k for k in [mediainfo.title,
+                                                       mediainfo.original_title,
+                                                       mediainfo.en_title,
+                                                       mediainfo.hk_title,
+                                                       mediainfo.tw_title,
+                                                       mediainfo.sg_title] if k]))
+
         # 执行搜索
         torrents: List[TorrentInfo] = self.__search_all_sites(
             mediainfo=mediainfo,
@@ -126,122 +175,120 @@ class SearchChain(ChainBase):
         if not torrents:
             logger.warn(f'{keyword or mediainfo.title} 未搜索到资源')
             return []
-        # 过滤种子
-        if priority_rule is None:
-            # 取搜索优先级规则
-            priority_rule = self.systemconfig.get(SystemConfigKey.SearchFilterRules)
-        if priority_rule:
-            logger.info(f'开始过滤资源，当前规则：{priority_rule} ...')
-            result: List[TorrentInfo] = self.filter_torrents(rule_string=priority_rule,
-                                                             torrent_list=torrents,
-                                                             season_episodes=season_episodes,
-                                                             mediainfo=mediainfo)
-            if result is not None:
-                torrents = result
+
+        # 开始新进度
+        progress = ProgressHelper()
+        progress.start(ProgressKey.Search)
+
+        # 开始过滤
+        progress.update(value=0, text=f'开始过滤，总 {len(torrents)} 个资源，请稍候...',
+                        key=ProgressKey.Search)
+        # 匹配订阅附加参数
+        if filter_params:
+            logger.info(f'开始附加参数过滤，附加参数：{filter_params} ...')
+            torrents = [torrent for torrent in torrents if TorrentHelper().filter_torrent(torrent, filter_params)]
+        # 开始过滤规则过滤
+        if rule_groups is None:
+            # 取搜索过滤规则
+            rule_groups: List[str] = SystemConfigOper().get(SystemConfigKey.SearchFilterRuleGroups)
+        if rule_groups:
+            logger.info(f'开始过滤规则/剧集过滤，使用规则组：{rule_groups} ...')
+            torrents = __do_filter(torrents)
             if not torrents:
-                logger.warn(f'{keyword or mediainfo.title} 没有符合优先级规则的资源')
+                logger.warn(f'{keyword or mediainfo.title} 没有符合过滤规则的资源')
                 return []
-        # 使用默认过滤规则再次过滤
-        torrents = self.filter_torrents_by_rule(torrents=torrents,
-                                                filter_rule=filter_rule)
-        if not torrents:
-            logger.warn(f'{keyword or mediainfo.title} 没有符合过滤规则的资源')
-            return []
-        # 匹配的资源
-        _match_torrents = []
+            logger.info(f"过滤规则/剧集过滤完成，剩余 {len(torrents)} 个资源")
+
+        # 过滤完成
+        progress.update(value=50, text=f'过滤完成，剩余 {len(torrents)} 个资源', key=ProgressKey.Search)
+
         # 总数
         _total = len(torrents)
         # 已处理数
         _count = 0
-        if mediainfo:
-            self.progress.start(ProgressKey.Search)
-            logger.info(f'开始匹配，总 {_total} 个资源 ...')
-            self.progress.update(value=0, text=f'开始匹配，总 {_total} 个资源 ...', key=ProgressKey.Search)
+
+        # 开始匹配
+        _match_torrents = []
+        torrenthelper = TorrentHelper()
+        try:
+            # 英文标题应该在别名/原标题中，不需要再匹配
+            logger.info(f"开始匹配结果 标题：{mediainfo.title}，原标题：{mediainfo.original_title}，别名：{mediainfo.names}")
+            progress.update(value=51, text=f'开始匹配，总 {_total} 个资源 ...', key=ProgressKey.Search)
             for torrent in torrents:
+                if global_vars.is_system_stopped:
+                    break
                 _count += 1
-                self.progress.update(value=(_count / _total) * 100,
-                                     text=f'正在匹配 {torrent.site_name}，已完成 {_count} / {_total} ...',
-                                     key=ProgressKey.Search)
+                progress.update(value=(_count / _total) * 96,
+                                text=f'正在匹配 {torrent.site_name}，已完成 {_count} / {_total} ...',
+                                key=ProgressKey.Search)
+                if not torrent.title:
+                    continue
+
+                # 识别元数据
+                torrent_meta = MetaInfo(title=torrent.title, subtitle=torrent.description,
+                                        custom_words=custom_words)
+                if torrent.title != torrent_meta.org_string:
+                    logger.info(f"种子名称应用识别词后发生改变：{torrent.title} => {torrent_meta.org_string}")
+                # 季集数过滤
+                if season_episodes \
+                        and not torrenthelper.match_season_episodes(torrent=torrent,
+                                                                    meta=torrent_meta,
+                                                                    season_episodes=season_episodes):
+                    continue
                 # 比对IMDBID
                 if torrent.imdbid \
                         and mediainfo.imdb_id \
                         and torrent.imdbid == mediainfo.imdb_id:
-                    logger.info(f'{mediainfo.title} 匹配到资源：{torrent.site_name} - {torrent.title}')
-                    _match_torrents.append(torrent)
+                    logger.info(f'{mediainfo.title} 通过IMDBID匹配到资源：{torrent.site_name} - {torrent.title}')
+                    _match_torrents.append((torrent, torrent_meta))
                     continue
-                # 识别
-                torrent_meta = MetaInfo(title=torrent.title, subtitle=torrent.description)
-                # 比对类型
-                if (torrent_meta.type == MediaType.TV and mediainfo.type != MediaType.TV) \
-                        or (torrent_meta.type != MediaType.TV and mediainfo.type == MediaType.TV):
-                    logger.warn(f'{torrent.site_name} - {torrent.title} 类型不匹配')
+
+                # 比对种子
+                if torrenthelper.match_torrent(mediainfo=mediainfo,
+                                               torrent_meta=torrent_meta,
+                                               torrent=torrent):
+                    # 匹配成功
+                    _match_torrents.append((torrent, torrent_meta))
                     continue
-                # 比对年份
-                if mediainfo.year:
-                    if mediainfo.type == MediaType.TV:
-                        # 剧集年份，每季的年份可能不同
-                        if torrent_meta.year and torrent_meta.year not in [year for year in
-                                                                           mediainfo.season_years.values()]:
-                            logger.warn(f'{torrent.site_name} - {torrent.title} 年份不匹配')
-                            continue
-                    else:
-                        # 电影年份，上下浮动1年
-                        if torrent_meta.year not in [str(int(mediainfo.year) - 1),
-                                                     mediainfo.year,
-                                                     str(int(mediainfo.year) + 1)]:
-                            logger.warn(f'{torrent.site_name} - {torrent.title} 年份不匹配')
-                            continue
-                # 比对标题和原语种标题
-                meta_name = StringUtils.clear_upper(torrent_meta.name)
-                if meta_name in [
-                    StringUtils.clear_upper(mediainfo.title),
-                    StringUtils.clear_upper(mediainfo.original_title)
-                ]:
-                    logger.info(f'{mediainfo.title} 通过标题匹配到资源：{torrent.site_name} - {torrent.title}')
-                    _match_torrents.append(torrent)
-                    continue
-                # 在副标题中判断是否存在标题与原语种标题
-                if torrent.description:
-                    subtitle = torrent.description.split()
-                    if (StringUtils.is_chinese(mediainfo.title)
-                        and str(mediainfo.title) in subtitle) \
-                            or (StringUtils.is_chinese(mediainfo.original_title)
-                                and str(mediainfo.original_title) in subtitle):
-                        logger.info(f'{mediainfo.title} 通过副标题匹配到资源：{torrent.site_name} - {torrent.title}，'
-                                    f'副标题：{torrent.description}')
-                        _match_torrents.append(torrent)
-                        continue
-                # 比对别名和译名
-                for name in mediainfo.names:
-                    if StringUtils.clear_upper(name) == meta_name:
-                        logger.info(f'{mediainfo.title} 通过别名或译名匹配到资源：{torrent.site_name} - {torrent.title}')
-                        _match_torrents.append(torrent)
-                        break
-                else:
-                    logger.warn(f'{torrent.site_name} - {torrent.title} 标题不匹配')
-            self.progress.update(value=100,
-                                 text=f'匹配完成，共匹配到 {len(_match_torrents)} 个资源',
-                                 key=ProgressKey.Search)
-            self.progress.end(ProgressKey.Search)
-        else:
-            _match_torrents = torrents
-        logger.info(f"匹配完成，共匹配到 {len(_match_torrents)} 个资源")
-        # 去掉mediainfo中多余的数据
-        mediainfo.clear()
-        # 组装上下文
-        contexts = [Context(meta_info=MetaInfo(title=torrent.title, subtitle=torrent.description),
-                            media_info=mediainfo,
-                            torrent_info=torrent) for torrent in _match_torrents]
+            # 匹配完成
+            logger.info(f"匹配完成，共匹配到 {len(_match_torrents)} 个资源")
+            progress.update(value=97,
+                            text=f'匹配完成，共匹配到 {len(_match_torrents)} 个资源',
+                            key=ProgressKey.Search)
+
+            # 去掉mediainfo中多余的数据
+            mediainfo.clear()
+            # 组装上下文
+            contexts = [Context(torrent_info=t[0],
+                                media_info=mediainfo,
+                                meta_info=t[1]) for t in _match_torrents]
+        finally:
+            torrents.clear()
+            del torrents
+            _match_torrents.clear()
+            del _match_torrents
+
         # 排序
-        contexts = self.torrenthelper.sort_torrents(contexts)
+        progress.update(value=99,
+                        text=f'正在对 {len(contexts)} 个资源进行排序，请稍候...',
+                        key=ProgressKey.Search)
+        contexts = torrenthelper.sort_torrents(contexts)
+
+        # 结束进度
+        logger.info(f'搜索完成，共 {len(contexts)} 个资源')
+        progress.update(value=100,
+                        text=f'搜索完成，共 {len(contexts)} 个资源',
+                        key=ProgressKey.Search)
+        progress.end(ProgressKey.Search)
+
         # 返回
         return contexts
 
     def __search_all_sites(self, keywords: List[str],
                            mediainfo: Optional[MediaInfo] = None,
                            sites: List[int] = None,
-                           page: int = 0,
-                           area: str = "title") -> Optional[List[TorrentInfo]]:
+                           page: Optional[int] = 0,
+                           area: Optional[str] = "title") -> Optional[List[TorrentInfo]]:
         """
         多线程搜索多个站点
         :param mediainfo:  识别的媒体信息
@@ -256,23 +303,19 @@ class SearchChain(ChainBase):
 
         # 配置的索引站点
         if not sites:
-            sites = self.systemconfig.get(SystemConfigKey.IndexerSites) or []
+            sites = SystemConfigOper().get(SystemConfigKey.IndexerSites) or []
 
-        for indexer in self.siteshelper.get_indexers():
+        for indexer in SitesHelper().get_indexers():
             # 检查站点索引开关
             if not sites or indexer.get("id") in sites:
-                # 站点流控
-                state, msg = self.siteshelper.check(indexer.get("domain"))
-                if state:
-                    logger.warn(msg)
-                    continue
                 indexer_sites.append(indexer)
         if not indexer_sites:
             logger.warn('未开启任何有效站点，无法搜索资源')
             return []
 
         # 开始进度
-        self.progress.start(ProgressKey.Search)
+        progress = ProgressHelper()
+        progress.start(ProgressKey.Search)
         # 开始计时
         start_time = datetime.now()
         # 总数
@@ -280,86 +323,69 @@ class SearchChain(ChainBase):
         # 完成数
         finish_count = 0
         # 更新进度
-        self.progress.update(value=0,
-                             text=f"开始搜索，共 {total_num} 个站点 ...",
-                             key=ProgressKey.Search)
-        # 多线程
-        executor = ThreadPoolExecutor(max_workers=len(indexer_sites))
-        all_task = []
-        for site in indexer_sites:
-            if area == "imdbid":
-                # 搜索IMDBID
-                task = executor.submit(self.search_torrents, site=site,
-                                       keywords=[mediainfo.imdb_id] if mediainfo else None,
-                                       mtype=mediainfo.type if mediainfo else None,
-                                       page=page)
-            else:
-                # 搜索标题
-                task = executor.submit(self.search_torrents, site=site,
-                                       keywords=keywords,
-                                       mtype=mediainfo.type if mediainfo else None,
-                                       page=page)
-            all_task.append(task)
+        progress.update(value=0,
+                        text=f"开始搜索，共 {total_num} 个站点 ...",
+                        key=ProgressKey.Search)
         # 结果集
         results = []
-        for future in as_completed(all_task):
-            finish_count += 1
-            result = future.result()
-            if result:
-                results.extend(result)
-            logger.info(f"站点搜索进度：{finish_count} / {total_num}")
-            self.progress.update(value=finish_count / total_num * 100,
-                                 text=f"正在搜索{keywords or ''}，已完成 {finish_count} / {total_num} 个站点 ...",
-                                 key=ProgressKey.Search)
+        # 多线程
+        with ThreadPoolExecutor(max_workers=len(indexer_sites)) as executor:
+            all_task = []
+            for site in indexer_sites:
+                if area == "imdbid":
+                    # 搜索IMDBID
+                    task = executor.submit(self.search_torrents, site=site,
+                                           keywords=[mediainfo.imdb_id] if mediainfo else None,
+                                           mtype=mediainfo.type if mediainfo else None,
+                                           page=page)
+                else:
+                    # 搜索标题
+                    task = executor.submit(self.search_torrents, site=site,
+                                           keywords=keywords,
+                                           mtype=mediainfo.type if mediainfo else None,
+                                           page=page)
+                all_task.append(task)
+            for future in as_completed(all_task):
+                if global_vars.is_system_stopped:
+                    break
+                finish_count += 1
+                result = future.result()
+                if result:
+                    results.extend(result)
+                logger.info(f"站点搜索进度：{finish_count} / {total_num}")
+                progress.update(value=finish_count / total_num * 100,
+                                text=f"正在搜索{keywords or ''}，已完成 {finish_count} / {total_num} 个站点 ...",
+                                key=ProgressKey.Search)
         # 计算耗时
         end_time = datetime.now()
         # 更新进度
-        self.progress.update(value=100,
-                             text=f"站点搜索完成，有效资源数：{len(results)}，总耗时 {(end_time - start_time).seconds} 秒",
-                             key=ProgressKey.Search)
+        progress.update(value=100,
+                        text=f"站点搜索完成，有效资源数：{len(results)}，总耗时 {(end_time - start_time).seconds} 秒",
+                        key=ProgressKey.Search)
         logger.info(f"站点搜索完成，有效资源数：{len(results)}，总耗时 {(end_time - start_time).seconds} 秒")
         # 结束进度
-        self.progress.end(ProgressKey.Search)
+        progress.end(ProgressKey.Search)
+
         # 返回
         return results
 
-    def filter_torrents_by_rule(self,
-                                torrents: List[TorrentInfo],
-                                filter_rule: Dict[str, str] = None
-                                ) -> List[TorrentInfo]:
+    @eventmanager.register(EventType.SiteDeleted)
+    def remove_site(self, event: Event):
         """
-        使用过滤规则过滤种子
-        :param torrents: 种子列表
-        :param filter_rule: 过滤规则
+        从搜索站点中移除与已删除站点相关的设置
         """
-
-        # 取默认过滤规则
-        if not filter_rule:
-            filter_rule = self.systemconfig.get(SystemConfigKey.DefaultFilterRules)
-        if not filter_rule:
-            return torrents
-        # 包含
-        include = filter_rule.get("include")
-        # 排除
-        exclude = filter_rule.get("exclude")
-
-        def __filter_torrent(t: TorrentInfo) -> bool:
-            """
-            过滤种子
-            """
-            # 包含
-            if include:
-                if not re.search(r"%s" % include,
-                                 f"{t.title} {t.description}", re.I):
-                    logger.info(f"{t.title} 不匹配包含规则 {include}")
-                    return False
-            # 排除
-            if exclude:
-                if re.search(r"%s" % exclude,
-                             f"{t.title} {t.description}", re.I):
-                    logger.info(f"{t.title} 匹配排除规则 {exclude}")
-                    return False
-            return True
-
-        # 使用默认过滤规则再次过滤
-        return list(filter(lambda t: __filter_torrent(t), torrents))
+        if not event:
+            return
+        event_data = event.event_data or {}
+        site_id = event_data.get("site_id")
+        if not site_id:
+            return
+        if site_id == "*":
+            # 清空搜索站点
+            SystemConfigOper().set(SystemConfigKey.IndexerSites, [])
+            return
+        # 从选中的rss站点中移除
+        selected_sites = SystemConfigOper().get(SystemConfigKey.IndexerSites) or []
+        if site_id in selected_sites:
+            selected_sites.remove(site_id)
+            SystemConfigOper().set(SystemConfigKey.IndexerSites, selected_sites)

app/chain/site.py

@@ -1,18 +1,27 @@
+import base64
+import gc
 import re
-from typing import Union, Tuple
+from datetime import datetime
+from typing import Optional, Tuple, Union, Dict
+from urllib.parse import urljoin
 
-from sqlalchemy.orm import Session
+from lxml import etree
 
 from app.chain import ChainBase
-from app.core.config import settings
+from app.core.config import global_vars, settings
+from app.core.event import Event, EventManager, eventmanager
 from app.db.models.site import Site
 from app.db.site_oper import SiteOper
+from app.db.systemconfig_oper import SystemConfigOper
 from app.helper.browser import PlaywrightHelper
 from app.helper.cloudflare import under_challenge
 from app.helper.cookie import CookieHelper
-from app.helper.message import MessageHelper
+from app.helper.cookiecloud import CookieCloudHelper
+from app.helper.rss import RssHelper
+from app.helper.sites import SitesHelper
 from app.log import logger
-from app.schemas import MessageChannel, Notification
+from app.schemas import MessageChannel, Notification, SiteUserData
+from app.schemas.types import EventType, NotificationType
 from app.utils.http import RequestUtils
 from app.utils.site import SiteUtils
 from app.utils.string import StringUtils
@@ -23,18 +32,94 @@ class SiteChain(ChainBase):
     站点管理处理链
     """
 
-    def __init__(self, db: Session = None):
-        super().__init__(db)
-        self.siteoper = SiteOper(self._db)
-        self.cookiehelper = CookieHelper()
-        self.message = MessageHelper()
+    def __init__(self):
+        super().__init__()
 
         # 特殊站点登录验证
         self.special_site_test = {
             "zhuque.in": self.__zhuque_test,
-            # "m-team.io": self.__mteam_test,
+            "m-team.io": self.__mteam_test,
+            "m-team.cc": self.__mteam_test,
+            "ptlsp.com": self.__indexphp_test,
+            "1ptba.com": self.__indexphp_test,
+            "star-space.net": self.__indexphp_test,
+            "yemapt.org": self.__yema_test,
+            "hddolby.com": self.__hddolby_test,
         }
 
+    def refresh_userdata(self, site: dict = None) -> Optional[SiteUserData]:
+        """
+        刷新站点的用户数据
+        :param site:  站点
+        :return: 用户数据
+        """
+        userdata: SiteUserData = self.run_module("refresh_userdata", site=site)
+        if userdata:
+            SiteOper().update_userdata(domain=StringUtils.get_url_domain(site.get("domain")),
+                                       name=site.get("name"),
+                                       payload=userdata.dict())
+            # 发送事件
+            EventManager().send_event(EventType.SiteRefreshed, {
+                "site_id": site.get("id")
+            })
+            # 发送站点消息
+            if userdata.message_unread:
+                if userdata.message_unread_contents and len(userdata.message_unread_contents) > 0:
+                    for head, date, content in userdata.message_unread_contents:
+                        msg_title = f"【站点 {site.get('name')} 消息】"
+                        msg_text = f"时间：{date}\n标题：{head}\n内容：\n{content}"
+                        self.post_message(Notification(
+                            mtype=NotificationType.SiteMessage,
+                            title=msg_title, text=msg_text, link=site.get("url")
+                        ))
+                else:
+                    self.post_message(Notification(
+                        mtype=NotificationType.SiteMessage,
+                        title=f"站点 {site.get('name')} 收到 "
+                              f"{userdata.message_unread} 条新消息，请登陆查看",
+                        link=site.get("url")
+                    ))
+            # 低分享率警告
+            if userdata.ratio and float(userdata.ratio) < 1 and not bool(
+                    re.search(r"(贵宾|VIP?)", userdata.user_level or "", re.IGNORECASE)):
+                self.post_message(Notification(
+                    mtype=NotificationType.SiteMessage,
+                    title=f"【站点分享率低预警】",
+                    text=f"站点 {site.get('name')} 分享率 {userdata.ratio}，请注意！"
+                ))
+        return userdata
+
+    def refresh_userdatas(self) -> Optional[Dict[str, SiteUserData]]:
+        """
+        刷新所有站点的用户数据
+        """
+        any_site_updated = False
+        result = {}
+        for site in SitesHelper().get_indexers():
+            if global_vars.is_system_stopped:
+                return None
+            if site.get("is_active"):
+                userdata = self.refresh_userdata(site)
+                if userdata:
+                    any_site_updated = True
+                    result[site.get("name")] = userdata
+        if any_site_updated:
+            EventManager().send_event(EventType.SiteRefreshed, {
+                "site_id": "*"
+            })
+
+        # 如果不是大内存模式，进行垃圾回收
+        if not settings.BIG_MEMORY_MODE:
+            gc.collect()
+
+        return result
+
+    def is_special_site(self, domain: str) -> bool:
+        """
+        判断是否特殊站点
+        """
+        return domain in self.special_site_test
+
     @staticmethod
     def __zhuque_test(site: Site) -> Tuple[bool, str]:
         """
@@ -42,16 +127,21 @@ class SiteChain(ChainBase):
         """
         # 获取token
         token = None
+        user_agent = site.ua or settings.USER_AGENT
         res = RequestUtils(
-            ua=site.ua,
+            ua=user_agent,
             cookies=site.cookie,
             proxies=settings.PROXY if site.proxy else None,
-            timeout=15
+            timeout=site.timeout or 15
         ).get_res(url=site.url)
-        if res and res.status_code == 200:
+        if res is None:
+            return False, "无法打开网站！"
+        if res.status_code == 200:
             csrf_token = re.search(r'<meta name="x-csrf-token" content="(.+?)">', res.text)
             if csrf_token:
                 token = csrf_token.group(1)
+        else:
+            return False, f"错误：{res.status_code} {res.reason}"
         if not token:
             return False, "无法获取Token"
         # 调用查询用户信息接口
@@ -59,35 +149,370 @@ class SiteChain(ChainBase):
             headers={
                 'X-CSRF-TOKEN': token,
                 "Content-Type": "application/json; charset=utf-8",
-                "User-Agent": f"{site.ua}"
+                "User-Agent": f"{user_agent}"
             },
             cookies=site.cookie,
             proxies=settings.PROXY if site.proxy else None,
-            timeout=15
+            timeout=site.timeout or 15
         ).get_res(url=f"{site.url}api/user/getInfo")
-        if user_res and user_res.status_code == 200:
+        if user_res is None:
+            return False, "无法打开网站！"
+        if user_res.status_code == 200:
             user_info = user_res.json()
             if user_info and user_info.get("data"):
                 return True, "连接成功"
-        return False, "Cookie已失效"
+            return False, "Cookie已失效"
+        else:
+            return False, f"错误：{user_res.status_code} {user_res.reason}"
 
     @staticmethod
     def __mteam_test(site: Site) -> Tuple[bool, str]:
         """
         判断站点是否已经登陆：m-team
         """
-        url = f"{site.url}api/member/profile"
+        user_agent = site.ua or settings.USER_AGENT
+        domain = StringUtils.get_url_domain(site.url)
+        url = f"https://api.{domain}/api/member/profile"
+        headers = {
+            "User-Agent": user_agent,
+            "Accept": "application/json, text/plain, */*",
+            "x-api-key": site.apikey,
+        }
         res = RequestUtils(
-            ua=site.ua,
+            headers=headers,
+            proxies=settings.PROXY if site.proxy else None,
+            timeout=site.timeout or 15
+        ).post_res(url=url)
+        if res is None:
+            return False, "无法打开网站！"
+        if res.status_code == 200:
+            user_info = res.json() or {}
+            if user_info.get("data"):
+                return True, "连接成功"
+            return False, user_info.get("message", "鉴权已过期或无效")
+        else:
+            return False, f"错误：{res.status_code} {res.reason}"
+
+    @staticmethod
+    def __yema_test(site: Site) -> Tuple[bool, str]:
+        """
+        判断站点是否已经登陆：yemapt
+        """
+        user_agent = site.ua or settings.USER_AGENT
+        url = f"{site.url}api/consumer/fetchSelfDetail"
+        headers = {
+            "User-Agent": user_agent,
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/plain, */*",
+        }
+        res = RequestUtils(
+            headers=headers,
             cookies=site.cookie,
             proxies=settings.PROXY if site.proxy else None,
-            timeout=15
-        ).post_res(url=url)
-        if res and res.status_code == 200:
+            timeout=site.timeout or 15
+        ).get_res(url=url)
+        if res is None:
+            return False, "无法打开网站！"
+        if res.status_code == 200:
             user_info = res.json()
-            if user_info and user_info.get("data"):
+            if user_info and user_info.get("success"):
                 return True, "连接成功"
-        return False, "Cookie已失效"
+            return False, "Cookie已过期"
+        else:
+            return False, f"错误：{res.status_code} {res.reason}"
+
+    def __indexphp_test(self, site: Site) -> Tuple[bool, str]:
+        """
+        判断站点是否已经登陆：ptlsp/1ptba
+        """
+        site.url = f"{site.url}index.php"
+        return self.__test(site)
+
+    @staticmethod
+    def __hddolby_test(site: Site) -> Tuple[bool, str]:
+        """
+        判断站点是否已经登陆：hddolby
+        """
+        url = f"{site.url}api/v1/user/data"
+        headers = {
+            "Content-Type": "application/json",
+            "Accept": "application/json, text/plain, */*",
+            "x-api-key": site.apikey,
+        }
+        res = RequestUtils(
+            headers=headers,
+            proxies=settings.PROXY if site.proxy else None,
+            timeout=site.timeout or 15
+        ).get_res(url=url)
+        if res is None:
+            return False, "无法打开网站！"
+        if res.status_code == 200:
+            user_info = res.json()
+            if user_info and user_info.get("status") == 0:
+                return True, "连接成功"
+            return False, "APIKEY已过期"
+        else:
+            return False, f"错误：{res.status_code} {res.reason}"
+
+    @staticmethod
+    def __parse_favicon(url: str, cookie: str, ua: str) -> Tuple[str, Optional[str]]:
+        """
+        解析站点favicon,返回base64 fav图标
+        :param url: 站点地址
+        :param cookie: Cookie
+        :param ua: User-Agent
+        :return:
+        """
+        favicon_url = urljoin(url, "favicon.ico")
+        res = RequestUtils(cookies=cookie, timeout=30, ua=ua).get_res(url=url)
+        if res:
+            html_text = res.text
+        else:
+            logger.error(f"获取站点页面失败：{url}")
+            return favicon_url, None
+        html = etree.HTML(html_text)
+        if StringUtils.is_valid_html_element(html):
+            fav_link = html.xpath('//head/link[contains(@rel, "icon")]/@href')
+            if fav_link:
+                favicon_url = urljoin(url, fav_link[0])
+
+        res = RequestUtils(cookies=cookie, timeout=15, ua=ua).get_res(url=favicon_url)
+        if res:
+            return favicon_url, base64.b64encode(res.content).decode()
+        else:
+            logger.error(f"获取站点图标失败：{favicon_url}")
+        return favicon_url, None
+
+    def sync_cookies(self, manual=False) -> Tuple[bool, str]:
+        """
+        通过CookieCloud同步站点Cookie
+        """
+
+        def __indexer_domain(inx: dict, sub_domain: str) -> str:
+            """
+            根据主域名获取索引器地址
+            """
+            if StringUtils.get_url_domain(inx.get("domain")) == sub_domain:
+                return inx.get("domain")
+            for ext_d in inx.get("ext_domains", []):
+                if StringUtils.get_url_domain(ext_d) == sub_domain:
+                    return ext_d
+            return sub_domain
+
+        logger.info("开始同步CookieCloud站点 ...")
+        cookies, msg = CookieCloudHelper().download()
+        if not cookies:
+            logger.error(f"CookieCloud同步失败：{msg}")
+            if manual:
+                self.messagehelper.put(msg, title="CookieCloud同步失败", role="system")
+            return False, msg
+        # 保存Cookie或新增站点
+        _update_count = 0
+        _add_count = 0
+        _fail_count = 0
+        siteshelper = SitesHelper()
+        siteoper = SiteOper()
+        rsshelper = RssHelper()
+        for domain, cookie in cookies.items():
+            # 索引器信息
+            indexer = siteshelper.get_indexer(domain)
+            # 数据库的站点信息
+            site_info = siteoper.get_by_domain(domain)
+            if site_info and site_info.is_active == 1:
+                # 站点已存在，检查站点连通性
+                status, msg = self.test(domain)
+                # 更新站点Cookie
+                if status:
+                    logger.info(f"站点【{site_info.name}】连通性正常，不同步CookieCloud数据")
+                    # 更新站点rss地址
+                    if not site_info.public and not site_info.rss:
+                        # 自动生成rss地址
+                        rss_url, errmsg = rsshelper.get_rss_link(
+                            url=site_info.url,
+                            cookie=cookie,
+                            ua=site_info.ua or settings.USER_AGENT,
+                            proxy=True if site_info.proxy else False
+                        )
+                        if rss_url:
+                            logger.info(f"更新站点 {domain} RSS地址 ...")
+                            siteoper.update_rss(domain=domain, rss=rss_url)
+                        else:
+                            logger.warn(errmsg)
+                    continue
+                # 更新站点Cookie
+                logger.info(f"更新站点 {domain} Cookie ...")
+                siteoper.update_cookie(domain=domain, cookies=cookie)
+                _update_count += 1
+            elif indexer:
+                if settings.COOKIECLOUD_BLACKLIST and any(
+                        StringUtils.get_url_domain(domain) == StringUtils.get_url_domain(black_domain) for black_domain
+                        in str(settings.COOKIECLOUD_BLACKLIST).split(",")):
+                    logger.warn(f"站点 {domain} 已在黑名单中，不添加站点")
+                    continue
+                # 新增站点
+                domain_url = __indexer_domain(inx=indexer, sub_domain=domain)
+                proxy = False
+                res = RequestUtils(cookies=cookie,
+                                   ua=settings.USER_AGENT
+                                   ).get_res(url=domain_url)
+                if res and res.status_code in [200, 500, 403]:
+                    content = res.text
+                    if not indexer.get("public") and not SiteUtils.is_logged_in(content):
+                        _fail_count += 1
+                        if under_challenge(content):
+                            logger.warn(f"站点 {indexer.get('name')} 被Cloudflare防护，无法登录，无法添加站点")
+                            continue
+                        logger.warn(
+                            f"站点 {indexer.get('name')} 登录失败，没有该站点账号或Cookie已失效，无法添加站点")
+                        continue
+                elif res is not None:
+                    _fail_count += 1
+                    logger.warn(f"站点 {indexer.get('name')} 连接状态码：{res.status_code}，无法添加站点")
+                    continue
+                else:
+                    if not settings.PROXY_HOST:
+                        _fail_count += 1
+                        logger.warn(f"站点 {indexer.get('name')} 连接失败，无法添加站点")
+                        continue
+                    else:
+                        # 如果配置了代理，尝试通过代理重试
+                        logger.info(f"站点 {indexer.get('name')} 初次连接失败，尝试通过代理重试...")
+                        proxy = True
+                        res = RequestUtils(cookies=cookie,
+                                           ua=settings.USER_AGENT,
+                                           proxies=settings.PROXY
+                                           ).get_res(url=domain_url)
+                        if res and res.status_code in [200, 500, 403]:
+                            if not indexer.get("public") and not SiteUtils.is_logged_in(res.text):
+                                logger.warn(f"站点 {indexer.get('name')} 登录失败，即使通过代理，无法添加站点")
+                                _fail_count += 1
+                                continue
+                            logger.info(f"站点 {indexer.get('name')} 通过代理连接成功")
+                        else:
+                            logger.warn(f"站点 {indexer.get('name')} 通过代理连接失败，无法添加站点")
+                            _fail_count += 1
+                            continue
+
+                # 获取rss地址
+                rss_url = None
+                if not indexer.get("public") and domain_url:
+                    # 自动生成rss地址
+                    rss_url, errmsg = rsshelper.get_rss_link(url=domain_url,
+                                                             cookie=cookie,
+                                                             ua=settings.USER_AGENT,
+                                                             proxy=proxy)
+                    if errmsg:
+                        logger.warn(errmsg)
+                # 插入数据库
+                logger.info(f"新增站点 {indexer.get('name')} ...")
+                siteoper.add(name=indexer.get("name"),
+                             url=domain_url,
+                             domain=domain,
+                             cookie=cookie,
+                             rss=rss_url,
+                             proxy=1 if proxy else 0,
+                             public=1 if indexer.get("public") else 0)
+                _add_count += 1
+
+            # 通知站点更新
+            if indexer:
+                EventManager().send_event(EventType.SiteUpdated, {
+                    "domain": domain,
+                })
+        # 处理完成
+        ret_msg = f"更新了{_update_count}个站点，新增了{_add_count}个站点"
+        if _fail_count > 0:
+            ret_msg += f"，{_fail_count}个站点添加失败，下次同步时将重试，也可以手动添加"
+        if manual:
+            self.messagehelper.put(ret_msg, title="CookieCloud同步成功", role="system")
+        logger.info(f"CookieCloud同步成功：{ret_msg}")
+        return True, ret_msg
+
+    @eventmanager.register(EventType.SiteUpdated)
+    def cache_site_icon(self, event: Event):
+        """
+        缓存站点图标
+        """
+        if not event:
+            return
+        event_data = event.event_data or {}
+        # 主域名
+        domain = event_data.get("domain")
+        if not domain:
+            return
+        if str(domain).startswith("http"):
+            domain = StringUtils.get_url_domain(domain)
+        # 站点信息
+        siteoper = SiteOper()
+        siteshelper = SitesHelper()
+        siteinfo = siteoper.get_by_domain(domain)
+        if not siteinfo:
+            logger.warn(f"未维护站点 {domain} 信息！")
+            return
+        # Cookie
+        cookie = siteinfo.cookie
+        # 索引器
+        indexer = siteshelper.get_indexer(domain)
+        if not indexer:
+            logger.warn(f"站点 {domain} 索引器不存在！")
+            return
+        # 查询站点图标
+        site_icon = siteoper.get_icon_by_domain(domain)
+        if not site_icon or not site_icon.base64:
+            logger.info(f"开始缓存站点 {indexer.get('name')} 图标 ...")
+            icon_url, icon_base64 = self.__parse_favicon(url=indexer.get("domain"),
+                                                         cookie=cookie,
+                                                         ua=settings.USER_AGENT)
+            if icon_url:
+                siteoper.update_icon(name=indexer.get("name"),
+                                     domain=domain,
+                                     icon_url=icon_url,
+                                     icon_base64=icon_base64)
+                logger.info(f"缓存站点 {indexer.get('name')} 图标成功")
+            else:
+                logger.warn(f"缓存站点 {indexer.get('name')} 图标失败")
+
+    @eventmanager.register(EventType.SiteUpdated)
+    def clear_site_data(self, event: Event):
+        """
+        清理站点数据
+        """
+        if not event:
+            return
+        event_data = event.event_data or {}
+        # 主域名
+        domain = event_data.get("domain")
+        if not domain:
+            return
+        # 获取主域名中间那段
+        domain_host = StringUtils.get_url_host(domain)
+        # 查询以"site.domain_host"开头的配置项，并清除
+        systemconfig = SystemConfigOper()
+        site_keys = systemconfig.all().keys()
+        for key in site_keys:
+            if key.startswith(f"site.{domain_host}"):
+                logger.info(f"清理站点配置：{key}")
+                systemconfig.delete(key)
+
+    @eventmanager.register(EventType.SiteUpdated)
+    def cache_site_userdata(self, event: Event):
+        """
+        缓存站点用户数据
+        """
+        if not event:
+            return
+        event_data = event.event_data or {}
+        # 主域名
+        domain = event_data.get("domain")
+        if not domain:
+            return
+        if str(domain).startswith("http"):
+            domain = StringUtils.get_url_domain(domain)
+        indexer = SitesHelper().get_indexer(domain)
+        if not indexer:
+            return
+        # 刷新站点用户数据
+        self.refresh_userdata(site=indexer) or {}
 
     def test(self, url: str) -> Tuple[bool, str]:
         """
@@ -97,73 +522,94 @@ class SiteChain(ChainBase):
         """
         # 检查域名是否可用
         domain = StringUtils.get_url_domain(url)
-        site_info = self.siteoper.get_by_domain(domain)
+        siteoper = SiteOper()
+        site_info = siteoper.get_by_domain(domain)
         if not site_info:
             return False, f"站点【{url}】不存在"
 
-        # 特殊站点测试
-        if self.special_site_test.get(domain):
-            return self.special_site_test[domain](site_info)
+        # 模拟登录
+        try:
+            # 开始记时
+            start_time = datetime.now()
+            # 特殊站点测试
+            if self.special_site_test.get(domain):
+                state, message = self.special_site_test[domain](site_info)
+            else:
+                # 通用站点测试
+                state, message = self.__test(site_info)
+            # 统计
+            seconds = (datetime.now() - start_time).seconds
+            if state:
+                siteoper.success(domain=domain, seconds=seconds)
+            else:
+                siteoper.fail(domain)
+            return state, message
+        except Exception as e:
+            return False, f"{str(e)}！"
 
-        # 通用站点测试
+    @staticmethod
+    def __test(site_info: Site) -> Tuple[bool, str]:
+        """
+        通用站点测试
+        """
         site_url = site_info.url
         site_cookie = site_info.cookie
-        ua = site_info.ua
+        ua = site_info.ua or settings.USER_AGENT
         render = site_info.render
         public = site_info.public
         proxies = settings.PROXY if site_info.proxy else None
         proxy_server = settings.PROXY_SERVER if site_info.proxy else None
-        # 模拟登录
-        try:
-            # 访问链接
-            if render:
-                page_source = PlaywrightHelper().get_page_source(url=site_url,
-                                                                 cookies=site_cookie,
-                                                                 ua=ua,
-                                                                 proxies=proxy_server)
-                if not public and not SiteUtils.is_logged_in(page_source):
-                    if under_challenge(page_source):
-                        return False, f"无法通过Cloudflare！"
-                    return False, f"仿真登录失败，Cookie已失效！"
+
+        # 访问链接
+        if render:
+            page_source = PlaywrightHelper().get_page_source(url=site_url,
+                                                             cookies=site_cookie,
+                                                             ua=ua,
+                                                             proxies=proxy_server)
+            if not public and not SiteUtils.is_logged_in(page_source):
+                if under_challenge(page_source):
+                    return False, f"无法通过Cloudflare！"
+                return False, f"仿真登录失败，Cookie已失效！"
+        else:
+            res = RequestUtils(cookies=site_cookie,
+                               ua=ua,
+                               proxies=proxies
+                               ).get_res(url=site_url)
+            # 判断登录状态
+            if res and res.status_code in [200, 500, 403]:
+                content = res.text
+                if not public and not SiteUtils.is_logged_in(content):
+                    if under_challenge(content):
+                        msg = "站点被Cloudflare防护，请打开站点浏览器仿真"
+                    elif res.status_code == 200:
+                        msg = "Cookie已失效"
+                    else:
+                        msg = f"错误：{res.status_code} {res.reason}"
+                    return False, f"{msg}！"
+                elif public and res.status_code != 200:
+                    return False, f"错误：{res.status_code} {res.reason}！"
+            elif res is not None:
+                return False, f"错误：{res.status_code} {res.reason}！"
             else:
-                res = RequestUtils(cookies=site_cookie,
-                                   ua=ua,
-                                   proxies=proxies
-                                   ).get_res(url=site_url)
-                # 判断登录状态
-                if res and res.status_code in [200, 500, 403]:
-                    if not public and not SiteUtils.is_logged_in(res.text):
-                        if under_challenge(res.text):
-                            msg = "站点被Cloudflare防护，请打开站点浏览器仿真"
-                        elif res.status_code == 200:
-                            msg = "Cookie已失效"
-                        else:
-                            msg = f"状态码：{res.status_code}"
-                        return False, f"{msg}！"
-                    elif public and res.status_code != 200:
-                        return False, f"状态码：{res.status_code}！"
-                elif res is not None:
-                    return False, f"状态码：{res.status_code}！"
-                else:
-                    return False, f"无法打开网站！"
-        except Exception as e:
-            return False, f"{str(e)}！"
+                return False, f"无法打开网站！"
         return True, "连接成功"
 
-    def remote_list(self, channel: MessageChannel, userid: Union[str, int] = None):
+    def remote_list(self, channel: MessageChannel,
+                    userid: Union[str, int] = None, source: Optional[str] = None):
         """
         查询所有站点，发送消息
         """
-        site_list = self.siteoper.list()
+        site_list = SiteOper().list()
         if not site_list:
             self.post_message(Notification(
                 channel=channel,
                 title="没有维护任何站点信息！",
-                userid=userid))
+                userid=userid,
+                link=settings.MP_DOMAIN('#/site')))
         title = f"共有 {len(site_list)} 个站点，回复对应指令操作：" \
                 f"\n- 禁用站点：/site_disable [id]" \
                 f"\n- 启用站点：/site_enable [id]" \
-                f"\n- 更新站点Cookie：/site_cookie [id] [username] [password]"
+                f"\n- 更新站点Cookie：/site_cookie [id] [username] [password] [2fa_code/secret]"
         messages = []
         for site in site_list:
             if site.render:
@@ -171,15 +617,19 @@ class SiteChain(ChainBase):
             else:
                 render_str = ""
             if site.is_active:
-                messages.append(f"{site.id}. [{site.name}]({site.url}){render_str}")
+                messages.append(f"{site.id}. {site.name} {render_str}")
             else:
-                messages.append(f"{site.id}. {site.name}")
+                messages.append(f"{site.id}. {site.name} ⚠️")
         # 发送列表
         self.post_message(Notification(
             channel=channel,
-            title=title, text="\n".join(messages), userid=userid))
+            source=source,
+            title=title, text="\n".join(messages), userid=userid,
+            link=settings.MP_DOMAIN('#/site'))
+        )
 
-    def remote_disable(self, arg_str, channel: MessageChannel, userid: Union[str, int] = None):
+    def remote_disable(self, arg_str: str, channel: MessageChannel,
+                       userid: Union[str, int] = None, source: Optional[str] = None):
         """
         禁用站点
         """
@@ -189,7 +639,8 @@ class SiteChain(ChainBase):
         if not arg_str.isdigit():
             return
         site_id = int(arg_str)
-        site = self.siteoper.get(site_id)
+        siteoper = SiteOper()
+        site = siteoper.get(site_id)
         if not site:
             self.post_message(Notification(
                 channel=channel,
@@ -197,99 +648,114 @@ class SiteChain(ChainBase):
                 userid=userid))
             return
         # 禁用站点
-        self.siteoper.update(site_id, {
+        siteoper.update(site_id, {
             "is_active": False
         })
         # 重新发送消息
-        self.remote_list(channel, userid)
+        self.remote_list(channel=channel, userid=userid, source=source)
 
-    def remote_enable(self, arg_str, channel: MessageChannel, userid: Union[str, int] = None):
+    def remote_enable(self, arg_str: str, channel: MessageChannel,
+                      userid: Union[str, int] = None, source: Optional[str] = None):
         """
         启用站点
         """
         if not arg_str:
             return
         arg_strs = str(arg_str).split()
+        siteoper = SiteOper()
         for arg_str in arg_strs:
             arg_str = arg_str.strip()
             if not arg_str.isdigit():
                 continue
             site_id = int(arg_str)
-            site = self.siteoper.get(site_id)
+            site = siteoper.get(site_id)
             if not site:
                 self.post_message(Notification(
                     channel=channel,
                     title=f"站点编号 {site_id} 不存在！", userid=userid))
                 return
             # 禁用站点
-            self.siteoper.update(site_id, {
+            siteoper.update(site_id, {
                 "is_active": True
             })
         # 重新发送消息
-        self.remote_list(channel, userid)
+        self.remote_list(channel=channel, userid=userid, source=source)
 
-    def update_cookie(self, site_info: Site,
-                      username: str, password: str) -> Tuple[bool, str]:
+    @staticmethod
+    def update_cookie(site_info: Site,
+                      username: str, password: str, two_step_code: Optional[str] = None) -> Tuple[bool, str]:
         """
         根据用户名密码更新站点Cookie
         :param site_info: 站点信息
         :param username: 用户名
         :param password: 密码
+        :param two_step_code: 二步验证码或密钥
         :return: (是否成功, 错误信息)
         """
         # 更新站点Cookie
-        result = self.cookiehelper.get_site_cookie_ua(
+        result = CookieHelper().get_site_cookie_ua(
             url=site_info.url,
             username=username,
             password=password,
+            two_step_code=two_step_code,
             proxies=settings.PROXY_HOST if site_info.proxy else None
         )
         if result:
             cookie, ua, msg = result
             if not cookie:
                 return False, msg
-            self.siteoper.update(site_info.id, {
+            SiteOper().update(site_info.id, {
                 "cookie": cookie,
                 "ua": ua
             })
             return True, msg
         return False, "未知错误"
 
-    def remote_cookie(self, arg_str: str, channel: MessageChannel, userid: Union[str, int] = None):
+    def remote_cookie(self, arg_str: str, channel: MessageChannel,
+                      userid: Union[str, int] = None, source: Optional[str] = None):
         """
         使用用户名密码更新站点Cookie
         """
-        err_title = "请输入正确的命令格式：/site_cookie [id] [username] [password]，" \
-                    "[id]为站点编号，[uername]为站点用户名，[password]为站点密码"
+        err_title = "请输入正确的命令格式：/site_cookie [id] [username] [password] [2fa_code/secret]，" \
+                    "[id]为站点编号，[uername]为站点用户名，[password]为站点密码，[2fa_code/secret]为站点二步验证码或密钥"
         if not arg_str:
             self.post_message(Notification(
                 channel=channel,
+                source=source,
                 title=err_title, userid=userid))
             return
         arg_str = str(arg_str).strip()
         args = arg_str.split()
-        if len(args) != 3:
+        # 二步验证码
+        two_step_code = None
+        if len(args) == 4:
+            two_step_code = args[3]
+        elif len(args) != 3:
             self.post_message(Notification(
                 channel=channel,
+                source=source,
                 title=err_title, userid=userid))
             return
         site_id = args[0]
         if not site_id.isdigit():
             self.post_message(Notification(
                 channel=channel,
+                source=source,
                 title=err_title, userid=userid))
             return
         # 站点ID
         site_id = int(site_id)
         # 站点信息
-        site_info = self.siteoper.get(site_id)
+        site_info = SiteOper().get(site_id)
         if not site_info:
             self.post_message(Notification(
                 channel=channel,
+                source=source,
                 title=f"站点编号 {site_id} 不存在！", userid=userid))
             return
         self.post_message(Notification(
             channel=channel,
+            source=source,
             title=f"开始更新【{site_info.name}】Cookie&UA ...", userid=userid))
         # 用户名
         username = args[1]
@@ -298,16 +764,82 @@ class SiteChain(ChainBase):
         # 更新Cookie
         status, msg = self.update_cookie(site_info=site_info,
                                          username=username,
-                                         password=password)
+                                         password=password,
+                                         two_step_code=two_step_code)
         if not status:
             logger.error(msg)
             self.post_message(Notification(
                 channel=channel,
+                source=source,
                 title=f"【{site_info.name}】 Cookie&UA更新失败！",
                 text=f"错误原因：{msg}",
                 userid=userid))
         else:
             self.post_message(Notification(
                 channel=channel,
+                source=source,
                 title=f"【{site_info.name}】 Cookie&UA更新成功",
                 userid=userid))
+
+    def remote_refresh_userdatas(self, channel: MessageChannel,
+                                 userid: Union[str, int] = None, source: Optional[str] = None):
+        """
+        刷新所有站点用户数据
+        """
+        logger.info("收到命令，开始刷新站点数据 ...")
+        self.post_message(Notification(
+            channel=channel,
+            source=source,
+            title="开始刷新站点数据 ...",
+            userid=userid
+        ))
+        # 刷新站点数据
+        site_datas = self.refresh_userdatas()
+        if site_datas:
+            # 发送消息
+            messages = {}
+            # 总上传
+            incUploads = 0
+            # 总下载
+            incDownloads = 0
+            # 今天日期
+            today_date = datetime.now().strftime("%Y-%m-%d")
+
+            for rand, site in enumerate(site_datas.keys()):
+                upload = int(site_datas[site].upload or 0)
+                download = int(site_datas[site].download or 0)
+                updated_date = site_datas[site].updated_day
+                if updated_date and updated_date != today_date:
+                    updated_date = f"（{updated_date}）"
+                else:
+                    updated_date = ""
+
+                if upload > 0 or download > 0:
+                    incUploads += upload
+                    incDownloads += download
+                    messages[upload + (rand / 1000)] = (
+                            f"【{site}】{updated_date}\n"
+                            + f"上传量：{StringUtils.str_filesize(upload)}\n"
+                            + f"下载量：{StringUtils.str_filesize(download)}\n"
+                            + "————————————"
+                    )
+            if incDownloads or incUploads:
+                sorted_messages = [messages[key] for key in sorted(messages.keys(), reverse=True)]
+                sorted_messages.insert(0, f"【汇总】\n"
+                                          f"总上传：{StringUtils.str_filesize(incUploads)}\n"
+                                          f"总下载：{StringUtils.str_filesize(incDownloads)}\n"
+                                          f"————————————")
+                self.post_message(Notification(
+                    channel=channel,
+                    source=source,
+                    title="【站点数据统计】",
+                    text="\n".join(sorted_messages),
+                    userid=userid
+                ))
+        else:
+            self.post_message(Notification(
+                channel=channel,
+                source=source,
+                title="没有刷新到任何站点数据！",
+                userid=userid
+            ))

app/chain/storage.py

@@ -0,0 +1,205 @@
+from pathlib import Path
+from typing import Optional, Tuple, List, Dict
+
+from app import schemas
+from app.chain import ChainBase
+from app.core.config import settings
+from app.helper.directory import DirectoryHelper
+from app.log import logger
+from app.schemas import MediaType
+
+
+class StorageChain(ChainBase):
+    """
+    存储处理链
+    """
+
+    def save_config(self, storage: str, conf: dict) -> None:
+        """
+        保存存储配置
+        """
+        self.run_module("save_config", storage=storage, conf=conf)
+
+    def reset_config(self, storage: str) -> None:
+        """
+        重置存储配置
+        """
+        self.run_module("reset_config", storage=storage)
+
+    def generate_qrcode(self, storage: str) -> Optional[Tuple[dict, str]]:
+        """
+        生成二维码
+        """
+        return self.run_module("generate_qrcode", storage=storage)
+
+    def check_login(self, storage: str, **kwargs) -> Optional[Tuple[dict, str]]:
+        """
+        登录确认
+        """
+        return self.run_module("check_login", storage=storage, **kwargs)
+
+    def list_files(self, fileitem: schemas.FileItem, recursion: bool = False) -> Optional[List[schemas.FileItem]]:
+        """
+        查询当前目录下所有目录和文件
+        """
+        return self.run_module("list_files", fileitem=fileitem, recursion=recursion)
+
+    def any_files(self, fileitem: schemas.FileItem, extensions: list = None) -> Optional[bool]:
+        """
+        查询当前目录下是否存在指定扩展名任意文件
+        """
+        return self.run_module("any_files", fileitem=fileitem, extensions=extensions)
+
+    def create_folder(self, fileitem: schemas.FileItem, name: str) -> Optional[schemas.FileItem]:
+        """
+        创建目录
+        """
+        return self.run_module("create_folder", fileitem=fileitem, name=name)
+
+    def download_file(self, fileitem: schemas.FileItem, path: Path = None) -> Optional[Path]:
+        """
+        下载文件
+        :param fileitem: 文件项
+        :param path: 本地保存路径
+        """
+        return self.run_module("download_file", fileitem=fileitem, path=path)
+
+    def upload_file(self, fileitem: schemas.FileItem, path: Path,
+                    new_name: Optional[str] = None) -> Optional[schemas.FileItem]:
+        """
+        上传文件
+        :param fileitem: 保存目录项
+        :param path: 本地文件路径
+        :param new_name: 新文件名
+        """
+        return self.run_module("upload_file", fileitem=fileitem, path=path, new_name=new_name)
+
+    def delete_file(self, fileitem: schemas.FileItem) -> Optional[bool]:
+        """
+        删除文件或目录
+        """
+        return self.run_module("delete_file", fileitem=fileitem)
+
+    def rename_file(self, fileitem: schemas.FileItem, name: str) -> Optional[bool]:
+        """
+        重命名文件或目录
+        """
+        return self.run_module("rename_file", fileitem=fileitem, name=name)
+
+    def exists(self, fileitem: schemas.FileItem) -> Optional[bool]:
+        """
+        判断文件或目录是否存在
+        """
+        return True if self.get_item(fileitem) else False
+
+    def get_item(self, fileitem: schemas.FileItem) -> Optional[schemas.FileItem]:
+        """
+        查询目录或文件
+        """
+        return self.get_file_item(storage=fileitem.storage, path=Path(fileitem.path))
+
+    def get_file_item(self, storage: str, path: Path) -> Optional[schemas.FileItem]:
+        """
+        根据路径获取文件项
+        """
+        return self.run_module("get_file_item", storage=storage, path=path)
+
+    def get_parent_item(self, fileitem: schemas.FileItem) -> Optional[schemas.FileItem]:
+        """
+        获取上级目录项
+        """
+        return self.run_module("get_parent_item", fileitem=fileitem)
+
+    def snapshot_storage(self, storage: str, path: Path) -> Optional[Dict[str, float]]:
+        """
+        快照存储
+        """
+        return self.run_module("snapshot_storage", storage=storage, path=path)
+
+    def storage_usage(self, storage: str) -> Optional[schemas.StorageUsage]:
+        """
+        存储使用情况
+        """
+        return self.run_module("storage_usage", storage=storage)
+
+    def support_transtype(self, storage: str) -> Optional[dict]:
+        """
+        获取支持的整理方式
+        """
+        return self.run_module("support_transtype", storage=storage)
+
+    def delete_media_file(self, fileitem: schemas.FileItem,
+                          mtype: MediaType = None, delete_self: bool = True) -> bool:
+        """
+        删除媒体文件，以及不含媒体文件的目录
+        """
+
+        def __is_bluray_dir(_fileitem: schemas.FileItem) -> bool:
+            """
+            检查是否蓝光目录
+            """
+            _dir_files = self.list_files(fileitem=_fileitem, recursion=False)
+            if _dir_files:
+                for _f in _dir_files:
+                    if _f.type == "dir" and _f.name in ["BDMV", "CERTIFICATE"]:
+                        return True
+            return False
+
+        media_exts = settings.RMT_MEDIAEXT + settings.DOWNLOAD_TMPEXT
+        if fileitem.path == "/" or len(Path(fileitem.path).parts) <= 2:
+            logger.warn(f"【{fileitem.storage}】{fileitem.path} 根目录或一级目录不允许删除")
+            return False
+        if fileitem.type == "dir":
+            # 本身是目录
+            if __is_bluray_dir(fileitem):
+                logger.warn(f"正在删除蓝光原盘目录：【{fileitem.storage}】{fileitem.path}")
+                if not self.delete_file(fileitem):
+                    logger.warn(f"【{fileitem.storage}】{fileitem.path} 删除失败")
+                    return False
+            elif self.any_files(fileitem, extensions=media_exts) is False:
+                logger.warn(f"【{fileitem.storage}】{fileitem.path} 不存在其它媒体文件，正在删除空目录")
+                if not self.delete_file(fileitem):
+                    logger.warn(f"【{fileitem.storage}】{fileitem.path} 删除失败")
+                    return False
+            # 不处理父目录
+            return True
+        elif delete_self:
+            # 本身是文件，需要删除文件
+            logger.warn(f"正在删除文件【{fileitem.storage}】{fileitem.path}")
+            if not self.delete_file(fileitem):
+                logger.warn(f"【{fileitem.storage}】{fileitem.path} 删除失败")
+                return False
+
+        if mtype:
+            # 重命名格式
+            rename_format = settings.TV_RENAME_FORMAT \
+                if mtype == MediaType.TV else settings.MOVIE_RENAME_FORMAT
+            # 计算重命名中的文件夹层数
+            rename_format_level = len(rename_format.split("/")) - 1
+            if rename_format_level < 1:
+                return True
+            # 处理媒体文件根目录
+            dir_item = self.get_file_item(storage=fileitem.storage,
+                                          path=Path(fileitem.path).parents[rename_format_level - 1])
+        else:
+            # 处理上级目录
+            dir_item = self.get_parent_item(fileitem)
+
+        # 检查和删除上级目录
+        if dir_item and len(Path(dir_item.path).parts) > 2:
+            # 如何目录是所有下载目录、媒体库目录的上级，则不处理
+            for d in DirectoryHelper().get_dirs():
+                if d.download_path and Path(d.download_path).is_relative_to(Path(dir_item.path)):
+                    logger.debug(f"【{dir_item.storage}】{dir_item.path} 是下载目录本级或上级目录，不删除")
+                    return True
+                if d.library_path and Path(d.library_path).is_relative_to(Path(dir_item.path)):
+                    logger.debug(f"【{dir_item.storage}】{dir_item.path} 是媒体库目录本级或上级目录，不删除")
+                    return True
+            # 不存在其他媒体文件，删除空目录
+            if self.any_files(dir_item, extensions=media_exts) is False:
+                logger.warn(f"【{dir_item.storage}】{dir_item.path} 不存在其它媒体文件，正在删除空目录")
+                if not self.delete_file(dir_item):
+                    logger.warn(f"【{dir_item.storage}】{dir_item.path} 删除失败")
+                    return False
+
+        return True

app/chain/system.py

@@ -1,17 +1,291 @@
-from typing import Union
+import json
+import re
+import shutil
+from pathlib import Path
+from typing import Union, Optional
 
 from app.chain import ChainBase
+from app.core.config import settings
+from app.log import logger
 from app.schemas import Notification, MessageChannel
+from app.utils.http import RequestUtils
+from app.utils.system import SystemUtils
+from app.helper.system import SystemHelper
+from app.helper.plugin import PluginHelper
+from version import FRONTEND_VERSION, APP_VERSION
 
 
 class SystemChain(ChainBase):
     """
     系统级处理链
     """
-    def remote_clear_cache(self, channel: MessageChannel, userid: Union[int, str]):
+
+    _restart_file = "__system_restart__"
+
+    def remote_clear_cache(self, channel: MessageChannel, userid: Union[int, str], source: Optional[str] = None):
         """
         清理系统缓存
         """
         self.clear_cache()
-        self.post_message(Notification(channel=channel,
+        self.post_message(Notification(channel=channel, source=source,
                                        title=f"缓存清理完成！", userid=userid))
+
+    def restart(self, channel: MessageChannel, userid: Union[int, str], source: Optional[str] = None):
+        """
+        重启系统
+        """
+        from app.core.config import global_vars
+        
+        if channel and userid:
+            self.post_message(Notification(channel=channel, source=source,
+                                           title="系统正在重启，请耐心等候！", userid=userid))
+            # 保存重启信息
+            self.save_cache({
+                "channel": channel.value,
+                "userid": userid
+            }, self._restart_file)
+        # 主动备份一次插件
+        self.backup_plugins()
+        # 设置停止标志，通知所有模块准备停止
+        global_vars.stop_system()
+        # 重启
+        SystemHelper.restart()
+
+    @staticmethod
+    def backup_plugins():
+        """
+        备份插件到用户配置目录（仅docker环境）
+        """
+
+        # 非docker环境不处理
+        if not SystemUtils.is_docker():
+            return
+
+        try:
+            # 使用绝对路径确保准确性
+            plugins_dir = settings.ROOT_PATH / "app" / "plugins"
+            backup_dir = settings.CONFIG_PATH / "plugins_backup"
+
+            if not plugins_dir.exists():
+                logger.info("插件目录不存在，跳过备份")
+                return
+
+            # 确保备份目录存在
+            backup_dir.mkdir(parents=True, exist_ok=True)
+
+            # 需要排除的文件和目录
+            exclude_items = {"__init__.py", "__pycache__", ".DS_Store"}
+
+            # 遍历插件目录，备份除排除项外的所有内容
+            for item in plugins_dir.iterdir():
+                if item.name in exclude_items:
+                    continue
+
+                target_path = backup_dir / item.name
+
+                # 如果是目录
+                if item.is_dir():
+                    if target_path.exists():
+                        continue
+                    shutil.copytree(item, target_path)
+                    logger.info(f"已备份插件目录: {item.name}")
+                # 如果是文件
+                elif item.is_file():
+                    if target_path.exists():
+                        continue
+                    shutil.copy2(item, target_path)
+                    logger.info(f"已备份插件文件: {item.name}")
+
+            logger.info(f"插件备份完成，备份位置: {backup_dir}")
+
+        except Exception as e:
+            logger.error(f"插件备份失败: {str(e)}")
+
+    @staticmethod
+    def restore_plugins():
+        """
+        从备份恢复插件到app/plugins目录，恢复完成后删除备份（仅docker环境）
+        """
+
+        # 非docker环境不处理
+        if not SystemUtils.is_docker():
+            return
+
+        # 使用绝对路径确保准确性
+        plugins_dir = settings.ROOT_PATH / "app" / "plugins"
+        backup_dir = settings.CONFIG_PATH / "plugins_backup"
+
+        if not backup_dir.exists():
+            logger.info("插件备份目录不存在，跳过恢复")
+            return
+
+        # 系统被重置才恢复插件
+        if SystemHelper().is_system_reset():
+
+            # 确保插件目录存在
+            plugins_dir.mkdir(parents=True, exist_ok=True)
+
+            # 遍历备份目录，恢复所有内容
+            restored_count = 0
+            for item in backup_dir.iterdir():
+                target_path = plugins_dir / item.name
+                try:
+                    # 如果是目录，且目录内有内容
+                    if item.is_dir() and any(item.iterdir()):
+                        if target_path.exists():
+                            shutil.rmtree(target_path)
+                        shutil.copytree(item, target_path)
+                        logger.info(f"已恢复插件目录: {item.name}")
+                        # 安装依赖
+                        requirements_file = target_path / "requirements.txt"
+                        if requirements_file.exists():
+                            logger.info(f"正在安装插件 {item.name} 的依赖...")
+                            success, message = PluginHelper.pip_install_with_fallback(requirements_file)
+                            if not success:
+                                logger.warn(f"插件 {item.name} 依赖安装失败: {message}")
+                        restored_count += 1
+                    # 如果是文件
+                    elif item.is_file():
+                        shutil.copy2(item, target_path)
+                        logger.info(f"已恢复插件文件: {item.name}")
+                        restored_count += 1
+                except Exception as e:
+                    logger.error(f"恢复插件 {item.name} 时发生错误: {str(e)}")
+                    continue
+
+            logger.info(f"插件恢复完成，共恢复 {restored_count} 个项目")
+
+        # 删除备份目录
+        try:
+            shutil.rmtree(backup_dir)
+            logger.info(f"已删除插件备份目录: {backup_dir}")
+        except Exception as e:
+            logger.warning(f"删除备份目录失败: {str(e)}")
+
+    def __get_version_message(self) -> str:
+        """
+        获取版本信息文本
+        """
+        server_release_version = self.__get_server_release_version()
+        front_release_version = self.__get_front_release_version()
+        server_local_version = self.get_server_local_version()
+        front_local_version = self.get_frontend_version()
+        if server_release_version == server_local_version:
+            title = f"当前后端版本：{server_local_version}，已是最新版本\n"
+        else:
+            title = f"当前后端版本：{server_local_version}，远程版本：{server_release_version}\n"
+        if front_release_version == front_local_version:
+            title += f"当前前端版本：{front_local_version}，已是最新版本"
+        else:
+            title += f"当前前端版本：{front_local_version}，远程版本：{front_release_version}"
+        return title
+
+    def version(self, channel: MessageChannel, userid: Union[int, str], source: Optional[str] = None):
+        """
+        查看当前版本、远程版本
+        """
+        self.post_message(Notification(channel=channel, source=source,
+                                       title=self.__get_version_message(),
+                                       userid=userid))
+
+    def restart_finish(self):
+        """
+        如通过交互命令重启，
+        重启完发送msg
+        """
+        # 重启消息
+        restart_channel = self.load_cache(self._restart_file)
+        if restart_channel:
+            # 发送重启完成msg
+            if not isinstance(restart_channel, dict):
+                restart_channel = json.loads(restart_channel)
+            channel = next(
+                (channel for channel in MessageChannel.__members__.values() if
+                 channel.value == restart_channel.get('channel')), None)
+            userid = restart_channel.get('userid')
+
+            # 版本号
+            title = self.__get_version_message()
+            self.post_message(Notification(channel=channel,
+                                           title=f"系统已重启完成！\n{title}",
+                                           userid=userid))
+            self.remove_cache(self._restart_file)
+
+    @staticmethod
+    def __get_server_release_version():
+        """
+        获取后端V2最新版本
+        """
+        try:
+            # 获取所有发布的版本列表
+            response = RequestUtils(
+                proxies=settings.PROXY,
+                headers=settings.GITHUB_HEADERS
+            ).get_res("https://api.github.com/repos/jxxghp/MoviePilot/releases")
+            if response:
+                releases = [release['tag_name'] for release in response.json()]
+                v2_releases = [tag for tag in releases if re.match(r"^v2\.", tag)]
+                if not v2_releases:
+                    logger.warn("获取v2后端最新版本版本出错！")
+                else:
+                    # 找到最新的v2版本
+                    latest_v2 = sorted(v2_releases, key=lambda s: list(map(int, re.findall(r'\d+', s))))[-1]
+                    logger.info(f"获取到后端最新版本：{latest_v2}")
+                    return latest_v2
+            else:
+                logger.error("无法获取后端版本信息，请检查网络连接或GitHub API请求。")
+        except Exception as err:
+            logger.error(f"获取后端最新版本失败：{str(err)}")
+        return None
+
+    @staticmethod
+    def __get_front_release_version():
+        """
+        获取前端V2最新版本
+        """
+        try:
+            # 获取所有发布的版本列表
+            response = RequestUtils(
+                proxies=settings.PROXY,
+                headers=settings.GITHUB_HEADERS
+            ).get_res("https://api.github.com/repos/jxxghp/MoviePilot-Frontend/releases")
+            if response:
+                releases = [release['tag_name'] for release in response.json()]
+                v2_releases = [tag for tag in releases if re.match(r"^v2\.", tag)]
+                if not v2_releases:
+                    logger.warn("获取v2前端最新版本版本出错！")
+                else:
+                    # 找到最新的v2版本
+                    latest_v2 = sorted(v2_releases, key=lambda s: list(map(int, re.findall(r'\d+', s))))[-1]
+                    logger.info(f"获取到前端最新版本：{latest_v2}")
+                    return latest_v2
+            else:
+                logger.error("无法获取前端版本信息，请检查网络连接或GitHub API请求。")
+        except Exception as err:
+            logger.error(f"获取前端最新版本失败：{str(err)}")
+        return None
+
+    @staticmethod
+    def get_server_local_version():
+        """
+        查看当前版本
+        """
+        return APP_VERSION
+
+    @staticmethod
+    def get_frontend_version():
+        """
+        获取前端版本
+        """
+        if SystemUtils.is_frozen() and SystemUtils.is_windows():
+            version_file = settings.CONFIG_PATH.parent / "nginx" / "html" / "version.txt"
+        else:
+            version_file = Path(settings.FRONTEND_PATH) / "version.txt"
+        if version_file.exists():
+            try:
+                with open(version_file, 'r') as f:
+                    version = str(f.read()).strip()
+                return version
+            except Exception as err:
+                logger.debug(f"加载版本文件 {version_file} 出错：{str(err)}")
+        return FRONTEND_VERSION

app/chain/tmdb.py

@@ -1,36 +1,52 @@
 import random
 from typing import Optional, List
 
-from cachetools import cached, TTLCache
-
 from app import schemas
 from app.chain import ChainBase
-from app.core.config import settings
+from app.core.context import MediaInfo
 from app.schemas import MediaType
-from app.utils.singleton import Singleton
 
 
-class TmdbChain(ChainBase, metaclass=Singleton):
+class TmdbChain(ChainBase):
     """
-    TheMovieDB处理链
+    TheMovieDB处理链，单例运行
     """
 
-    def tmdb_discover(self, mtype: MediaType, sort_by: str, with_genres: str,
-                      with_original_language: str, page: int = 1) -> Optional[List[dict]]:
+    def tmdb_discover(self, mtype: MediaType,
+                      sort_by: str,
+                      with_genres: str,
+                      with_original_language: str,
+                      with_keywords: str,
+                      with_watch_providers: str,
+                      vote_average: float,
+                      vote_count: int,
+                      release_date: str,
+                      page: Optional[int] = 1) -> Optional[List[MediaInfo]]:
         """
         :param mtype:  媒体类型
         :param sort_by:  排序方式
         :param with_genres:  类型
         :param with_original_language:  语言
+        :param with_keywords:  关键字
+        :param with_watch_providers:  提供商
+        :param vote_average:  评分
+        :param vote_count:  评分人数
+        :param release_date:  上映日期
         :param page:  页码
         :return: 媒体信息列表
         """
         return self.run_module("tmdb_discover", mtype=mtype,
-                               sort_by=sort_by, with_genres=with_genres,
+                               sort_by=sort_by,
+                               with_genres=with_genres,
                                with_original_language=with_original_language,
+                               with_keywords=with_keywords,
+                               with_watch_providers=with_watch_providers,
+                               vote_average=vote_average,
+                               vote_count=vote_count,
+                               release_date=release_date,
                                page=page)
 
-    def tmdb_trending(self, page: int = 1) -> List[dict]:
+    def tmdb_trending(self, page: Optional[int] = 1) -> Optional[List[MediaInfo]]:
         """
         TMDB流行趋势
         :param page: 第几页
@@ -38,6 +54,13 @@ class TmdbChain(ChainBase, metaclass=Singleton):
         """
         return self.run_module("tmdb_trending", page=page)
 
+    def tmdb_collection(self, collection_id: int) -> Optional[List[MediaInfo]]:
+        """
+        根据合集ID查询集合
+        :param collection_id:  合集ID
+        """
+        return self.run_module("tmdb_collection", collection_id=collection_id)
+
     def tmdb_seasons(self, tmdbid: int) -> List[schemas.TmdbSeason]:
         """
         根据TMDBID查询themoviedb所有季信息
@@ -45,75 +68,82 @@ class TmdbChain(ChainBase, metaclass=Singleton):
         """
         return self.run_module("tmdb_seasons", tmdbid=tmdbid)
 
-    def tmdb_episodes(self, tmdbid: int, season: int) -> List[schemas.TmdbEpisode]:
+    def tmdb_group_seasons(self, group_id: str) -> List[schemas.TmdbSeason]:
+        """
+        根据剧集组ID查询themoviedb所有季集信息
+        :param group_id: 剧集组ID
+        """
+        return self.run_module("tmdb_group_seasons", group_id=group_id)
+
+    def tmdb_episodes(self, tmdbid: int, season: int, episode_group: Optional[str] = None) -> List[schemas.TmdbEpisode]:
         """
         根据TMDBID查询某季的所有信信息
         :param tmdbid:  TMDBID
         :param season:  季
+        :param episode_group:  剧集组
         """
-        return self.run_module("tmdb_episodes", tmdbid=tmdbid, season=season)
+        return self.run_module("tmdb_episodes", tmdbid=tmdbid, season=season, episode_group=episode_group)
 
-    def movie_similar(self, tmdbid: int) -> List[dict]:
+    def movie_similar(self, tmdbid: int) -> Optional[List[MediaInfo]]:
         """
         根据TMDBID查询类似电影
         :param tmdbid:  TMDBID
         """
-        return self.run_module("movie_similar", tmdbid=tmdbid)
+        return self.run_module("tmdb_movie_similar", tmdbid=tmdbid)
 
-    def tv_similar(self, tmdbid: int) -> List[dict]:
+    def tv_similar(self, tmdbid: int) -> Optional[List[MediaInfo]]:
         """
         根据TMDBID查询类似电视剧
         :param tmdbid:  TMDBID
         """
-        return self.run_module("tv_similar", tmdbid=tmdbid)
+        return self.run_module("tmdb_tv_similar", tmdbid=tmdbid)
 
-    def movie_recommend(self, tmdbid: int) -> List[dict]:
+    def movie_recommend(self, tmdbid: int) -> Optional[List[MediaInfo]]:
         """
         根据TMDBID查询推荐电影
         :param tmdbid:  TMDBID
         """
-        return self.run_module("movie_recommend", tmdbid=tmdbid)
+        return self.run_module("tmdb_movie_recommend", tmdbid=tmdbid)
 
-    def tv_recommend(self, tmdbid: int) -> List[dict]:
+    def tv_recommend(self, tmdbid: int) -> Optional[List[MediaInfo]]:
         """
         根据TMDBID查询推荐电视剧
         :param tmdbid:  TMDBID
         """
-        return self.run_module("tv_recommend", tmdbid=tmdbid)
+        return self.run_module("tmdb_tv_recommend", tmdbid=tmdbid)
 
-    def movie_credits(self, tmdbid: int, page: int = 1) -> List[dict]:
+    def movie_credits(self, tmdbid: int, page: Optional[int] = 1) -> Optional[List[schemas.MediaPerson]]:
         """
         根据TMDBID查询电影演职人员
         :param tmdbid:  TMDBID
         :param page:  页码
         """
-        return self.run_module("movie_credits", tmdbid=tmdbid, page=page)
+        return self.run_module("tmdb_movie_credits", tmdbid=tmdbid, page=page)
 
-    def tv_credits(self, tmdbid: int, page: int = 1) -> List[dict]:
+    def tv_credits(self, tmdbid: int, page: Optional[int] = 1) -> Optional[List[schemas.MediaPerson]]:
         """
         根据TMDBID查询电视剧演职人员
         :param tmdbid:  TMDBID
         :param page:  页码
         """
-        return self.run_module("tv_credits", tmdbid=tmdbid, page=page)
+        return self.run_module("tmdb_tv_credits", tmdbid=tmdbid, page=page)
 
-    def person_detail(self, person_id: int) -> dict:
+    def person_detail(self, person_id: int) -> Optional[schemas.MediaPerson]:
         """
         根据TMDBID查询演职员详情
         :param person_id:  人物ID
         """
-        return self.run_module("person_detail", person_id=person_id)
+        return self.run_module("tmdb_person_detail", person_id=person_id)
 
-    def person_credits(self, person_id: int, page: int = 1) -> List[dict]:
+    def person_credits(self, person_id: int, page: Optional[int] = 1) -> Optional[List[MediaInfo]]:
         """
         根据人物ID查询人物参演作品
         :param person_id:  人物ID
         :param page:  页码
         """
-        return self.run_module("person_credits", person_id=person_id, page=page)
+        return self.run_module("tmdb_person_credits", person_id=person_id, page=page)
 
-    @cached(cache=TTLCache(maxsize=1, ttl=3600))
-    def get_random_wallpager(self):
+    def get_random_wallpager(self) -> Optional[str]:
         """
         获取随机壁纸，缓存1个小时
         """
@@ -122,6 +152,15 @@ class TmdbChain(ChainBase, metaclass=Singleton):
             # 随机一个电影
             while True:
                 info = random.choice(infos)
-                if info and info.get("backdrop_path"):
-                    return f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/original{info.get('backdrop_path')}"
+                if info and info.backdrop_path:
+                    return info.backdrop_path
         return None
+
+    def get_trending_wallpapers(self, num: Optional[int] = 10) -> List[str]:
+        """
+        获取所有流行壁纸
+        """
+        infos = self.tmdb_trending()
+        if infos:
+            return [info.backdrop_path for info in infos if info and info.backdrop_path][:num]
+        return []

app/chain/torrents.py

@@ -1,25 +1,24 @@
 import re
-from typing import Dict, List, Union
-
-from cachetools import cached, TTLCache
+import traceback
+from typing import Dict, List, Union, Optional
 
 from app.chain import ChainBase
-from app.core.config import settings
+from app.chain.media import MediaChain
+from app.core.config import settings, global_vars
 from app.core.context import TorrentInfo, Context, MediaInfo
 from app.core.metainfo import MetaInfo
-from app.db import SessionFactory
 from app.db.site_oper import SiteOper
 from app.db.systemconfig_oper import SystemConfigOper
 from app.helper.rss import RssHelper
 from app.helper.sites import SitesHelper
+from app.helper.torrent import TorrentHelper
 from app.log import logger
 from app.schemas import Notification
-from app.schemas.types import SystemConfigKey, MessageChannel, NotificationType
-from app.utils.singleton import Singleton
+from app.schemas.types import SystemConfigKey, MessageChannel, NotificationType, MediaType
 from app.utils.string import StringUtils
 
 
-class TorrentsChain(ChainBase, metaclass=Singleton):
+class TorrentsChain(ChainBase):
     """
     站点首页或RSS种子处理链，服务于订阅、刷流等
     """
@@ -27,13 +26,14 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
     _spider_file = "__torrents_cache__"
     _rss_file = "__rss_cache__"
 
-    def __init__(self):
-        self._db = SessionFactory()
-        super().__init__(self._db)
-        self.siteshelper = SitesHelper()
-        self.siteoper = SiteOper(self._db)
-        self.rsshelper = RssHelper()
-        self.systemconfig = SystemConfigOper()
+    @property
+    def cache_file(self) -> str:
+        """
+        返回缓存文件列表
+        """
+        if settings.SUBSCRIBE_MODE == 'spider':
+            return self._spider_file
+        return self._rss_file
 
     def remote_refresh(self, channel: MessageChannel, userid: Union[str, int] = None):
         """
@@ -45,7 +45,7 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
         self.post_message(Notification(channel=channel,
                                        title=f"种子刷新完成！", userid=userid))
 
-    def get_torrents(self, stype: str = None) -> Dict[str, List[Context]]:
+    def get_torrents(self, stype: Optional[str] = None) -> Dict[str, List[Context]]:
         """
         获取当前缓存的种子
         :param stype: 强制指定缓存类型，spider:爬虫缓存，rss:rss缓存
@@ -60,34 +60,47 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
         else:
             return self.load_cache(self._rss_file) or {}
 
-    @cached(cache=TTLCache(maxsize=128 if settings.BIG_MEMORY_MODE else 1, ttl=600))
-    def browse(self, domain: str) -> List[TorrentInfo]:
+    def clear_torrents(self):
         """
-        浏览站点首页内容，返回种子清单，TTL缓存10分钟
+        清理种子缓存数据
+        """
+        logger.info(f'开始清理种子缓存数据 ...')
+        self.remove_cache(self._spider_file)
+        self.remove_cache(self._rss_file)
+        logger.info(f'种子缓存数据清理完成')
+
+    def browse(self, domain: str, keyword: Optional[str] = None, cat: Optional[str] = None,
+               page: Optional[int] = 0) -> List[TorrentInfo]:
+        """
+        浏览站点首页内容，返回种子清单，TTL缓存5分钟
         :param domain: 站点域名
+        :param keyword: 搜索标题
+        :param cat: 搜索分类
+        :param page: 页码
         """
         logger.info(f'开始获取站点 {domain} 最新种子 ...')
-        site = self.siteshelper.get_indexer(domain)
+        site = SitesHelper().get_indexer(domain)
         if not site:
             logger.error(f'站点 {domain} 不存在！')
             return []
-        return self.refresh_torrents(site=site)
+        return self.refresh_torrents(site=site, keyword=keyword, cat=cat, page=page)
 
-    @cached(cache=TTLCache(maxsize=128 if settings.BIG_MEMORY_MODE else 1, ttl=300))
     def rss(self, domain: str) -> List[TorrentInfo]:
         """
-        获取站点RSS内容，返回种子清单，TTL缓存5分钟
+        获取站点RSS内容，返回种子清单，TTL缓存3分钟
         :param domain: 站点域名
         """
         logger.info(f'开始获取站点 {domain} RSS ...')
-        site = self.siteshelper.get_indexer(domain)
+        site = SitesHelper().get_indexer(domain)
         if not site:
             logger.error(f'站点 {domain} 不存在！')
             return []
         if not site.get("rss"):
             logger.error(f'站点 {domain} 未配置RSS地址！')
             return []
-        rss_items = self.rsshelper.parse(site.get("rss"), True if site.get("proxy") else False)
+        # 解析RSS
+        rss_items = RssHelper().parse(site.get("rss"), True if site.get("proxy") else False,
+                                      timeout=int(site.get("timeout") or 30))
         if rss_items is None:
             # rss过期，尝试保留原配置生成新的rss
             self.__renew_rss_url(domain=domain, site=site)
@@ -97,27 +110,31 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
             return []
         # 组装种子
         ret_torrents: List[TorrentInfo] = []
-        for item in rss_items:
-            if not item.get("title"):
-                continue
-            torrentinfo = TorrentInfo(
-                site=site.get("id"),
-                site_name=site.get("name"),
-                site_cookie=site.get("cookie"),
-                site_ua=site.get("ua") or settings.USER_AGENT,
-                site_proxy=site.get("proxy"),
-                site_order=site.get("pri"),
-                title=item.get("title"),
-                enclosure=item.get("enclosure"),
-                page_url=item.get("link"),
-                size=item.get("size"),
-                pubdate=item["pubdate"].strftime("%Y-%m-%d %H:%M:%S") if item.get("pubdate") else None,
-            )
-            ret_torrents.append(torrentinfo)
-
+        try:
+            for item in rss_items:
+                if not item.get("title"):
+                    continue
+                torrentinfo = TorrentInfo(
+                    site=site.get("id"),
+                    site_name=site.get("name"),
+                    site_cookie=site.get("cookie"),
+                    site_ua=site.get("ua") or settings.USER_AGENT,
+                    site_proxy=site.get("proxy"),
+                    site_order=site.get("pri"),
+                    site_downloader=site.get("downloader"),
+                    title=item.get("title"),
+                    enclosure=item.get("enclosure"),
+                    page_url=item.get("link"),
+                    size=item.get("size"),
+                    pubdate=item["pubdate"].strftime("%Y-%m-%d %H:%M:%S") if item.get("pubdate") else None,
+                )
+                ret_torrents.append(torrentinfo)
+        finally:
+            rss_items.clear()
+            del rss_items
         return ret_torrents
 
-    def refresh(self, stype: str = None, sites: List[int] = None) -> Dict[str, List[Context]]:
+    def refresh(self, stype: Optional[str] = None, sites: List[int] = None) -> Dict[str, List[Context]]:
         """
         刷新站点最新资源，识别并缓存起来
         :param stype: 强制指定缓存类型，spider:爬虫缓存，rss:rss缓存
@@ -129,19 +146,27 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
 
         # 刷新站点
         if not sites:
-            sites = self.systemconfig.get(SystemConfigKey.RssSites) or []
+            sites = SystemConfigOper().get(SystemConfigKey.RssSites) or []
 
         # 读取缓存
         torrents_cache = self.get_torrents()
 
-        # 所有站点索引
-        indexers = self.siteshelper.get_indexers()
+        # 缓存过滤掉无效种子
+        for _domain, _torrents in torrents_cache.items():
+            torrents_cache[_domain] = [_torrent for _torrent in _torrents
+                                       if not TorrentHelper().is_invalid(_torrent.torrent_info.enclosure)]
+
+        # 需要刷新的站点domain
+        domains = []
         # 遍历站点缓存资源
-        for indexer in indexers:
+        for indexer in SitesHelper().get_indexers():
+            if global_vars.is_system_stopped:
+                break
             # 未开启的站点不刷新
             if sites and indexer.get("id") not in sites:
                 continue
             domain = StringUtils.get_url_domain(indexer.get("domain"))
+            domains.append(domain)
             if stype == "spider":
                 # 刷新首页种子
                 torrents: List[TorrentInfo] = self.browse(domain=domain)
@@ -151,42 +176,52 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
             # 按pubdate降序排列
             torrents.sort(key=lambda x: x.pubdate or '', reverse=True)
             # 取前N条
-            torrents = torrents[:settings.CACHE_CONF.get('refresh')]
+            torrents = torrents[:settings.CONF.refresh]
             if torrents:
-                # 过滤出没有处理过的种子
+                # 过滤出没有处理过的种子 - 优化：使用集合查找，避免重复创建字符串列表
+                cached_signatures = {f'{t.torrent_info.title}{t.torrent_info.description}'
+                                     for t in torrents_cache.get(domain) or []}
                 torrents = [torrent for torrent in torrents
-                            if f'{torrent.title}{torrent.description}'
-                            not in [f'{t.torrent_info.title}{t.torrent_info.description}'
-                                    for t in torrents_cache.get(domain) or []]]
+                            if f'{torrent.title}{torrent.description}' not in cached_signatures]
                 if torrents:
                     logger.info(f'{indexer.get("name")} 有 {len(torrents)} 个新种子')
                 else:
                     logger.info(f'{indexer.get("name")} 没有新种子')
                     continue
-                for torrent in torrents:
-                    logger.info(f'处理资源：{torrent.title} ...')
-                    # 识别
-                    meta = MetaInfo(title=torrent.title, subtitle=torrent.description)
-                    # 识别媒体信息
-                    mediainfo: MediaInfo = self.recognize_media(meta=meta)
-                    if not mediainfo:
-                        logger.warn(f'未识别到媒体信息，标题：{torrent.title}')
-                        # 存储空的媒体信息
-                        mediainfo = MediaInfo()
-                    # 清理多余数据
-                    mediainfo.clear()
-                    # 上下文
-                    context = Context(meta_info=meta, media_info=mediainfo, torrent_info=torrent)
-                    # 添加到缓存
-                    if not torrents_cache.get(domain):
-                        torrents_cache[domain] = [context]
-                    else:
-                        torrents_cache[domain].append(context)
-                    # 如果超过了限制条数则移除掉前面的
-                    if len(torrents_cache[domain]) > settings.CACHE_CONF.get('torrents'):
-                        torrents_cache[domain] = torrents_cache[domain][-settings.CACHE_CONF.get('torrents'):]
-                # 回收资源
-                del torrents
+                try:
+                    for torrent in torrents:
+                        if global_vars.is_system_stopped:
+                            break
+                        logger.info(f'处理资源：{torrent.title} ...')
+                        # 识别
+                        meta = MetaInfo(title=torrent.title, subtitle=torrent.description)
+                        if torrent.title != meta.org_string:
+                            logger.info(f'种子名称应用识别词后发生改变：{torrent.title} => {meta.org_string}')
+                        # 使用站点种子分类，校正类型识别
+                        if meta.type != MediaType.TV \
+                                and torrent.category == MediaType.TV.value:
+                            meta.type = MediaType.TV
+                        # 识别媒体信息
+                        mediainfo: MediaInfo = MediaChain().recognize_by_meta(meta)
+                        if not mediainfo:
+                            logger.warn(f'{torrent.title} 未识别到媒体信息')
+                            # 存储空的媒体信息
+                            mediainfo = MediaInfo()
+                        # 清理多余数据，减少内存占用
+                        mediainfo.clear()
+                        # 上下文
+                        context = Context(meta_info=meta, media_info=mediainfo, torrent_info=torrent)
+                        # 添加到缓存
+                        if not torrents_cache.get(domain):
+                            torrents_cache[domain] = [context]
+                        else:
+                            torrents_cache[domain].append(context)
+                        # 如果超过了限制条数则移除掉前面的
+                        if len(torrents_cache[domain]) > settings.CONF.torrents:
+                            torrents_cache[domain] = torrents_cache[domain][-settings.CONF.torrents:]
+                finally:
+                    torrents.clear()
+                    del torrents
             else:
                 logger.info(f'{indexer.get("name")} 没有获取到种子')
 
@@ -196,7 +231,10 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
         else:
             self.save_cache(torrents_cache, self._rss_file)
 
-        # 返回
+        # 去除不在站点范围内的缓存种子
+        if sites and torrents_cache:
+            torrents_cache = {k: v for k, v in torrents_cache.items() if k in domains}
+
         return torrents_cache
 
     def __renew_rss_url(self, domain: str, site: dict):
@@ -207,7 +245,7 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
             # RSS链接过期
             logger.error(f"站点 {domain} RSS链接已过期，正在尝试自动获取！")
             # 自动生成rss地址
-            rss_url, errmsg = self.rsshelper.get_rss_link(
+            rss_url, errmsg = RssHelper().get_rss_link(
                 url=site.get("url"),
                 cookie=site.get("cookie"),
                 ua=site.get("ua") or settings.USER_AGENT,
@@ -221,14 +259,18 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
                     # 获取过期rss除去passkey部分
                     new_rss = re.sub(r'&passkey=([a-zA-Z0-9]+)', f'&passkey={new_passkey}', site.get("rss"))
                     logger.info(f"更新站点 {domain} RSS地址 ...")
-                    self.siteoper.update_rss(domain=domain, rss=new_rss)
+                    SiteOper().update_rss(domain=domain, rss=new_rss)
                 else:
                     # 发送消息
                     self.post_message(
-                        Notification(mtype=NotificationType.SiteMessage, title=f"站点 {domain} RSS链接已过期"))
+                        Notification(mtype=NotificationType.SiteMessage, title=f"站点 {domain} RSS链接已过期",
+                                     link=settings.MP_DOMAIN('#/site'))
+                    )
             else:
                 self.post_message(
-                    Notification(mtype=NotificationType.SiteMessage, title=f"站点 {domain} RSS链接已过期"))
+                    Notification(mtype=NotificationType.SiteMessage, title=f"站点 {domain} RSS链接已过期",
+                                 link=settings.MP_DOMAIN('#/site')))
         except Exception as e:
-            print(str(e))
-            self.post_message(Notification(mtype=NotificationType.SiteMessage, title=f"站点 {domain} RSS链接已过期"))
+            logger.error(f"站点 {domain} RSS链接自动获取失败：{str(e)} - {traceback.format_exc()}")
+            self.post_message(Notification(mtype=NotificationType.SiteMessage, title=f"站点 {domain} RSS链接已过期",
+                                           link=settings.MP_DOMAIN('#/site')))

app/chain/tvdb.py

@@ -0,0 +1,13 @@
+from typing import List
+
+from app.chain import ChainBase
+
+
+class TvdbChain(ChainBase):
+    """
+    Tvdb处理链，单例运行
+    """
+
+    def get_tvdbid_by_name(self, title: str) -> List[int]:
+        tvdb_info_list = self.run_module("search_tvdb", title=title)
+        return [int(item["tvdb_id"]) for item in tvdb_info_list]

app/chain/user.py

@@ -1,15 +1,235 @@
-from typing import Optional
+import secrets
+from typing import Optional, Tuple, Union
 
 from app.chain import ChainBase
+from app.core.config import settings
+from app.core.security import get_password_hash, verify_password
+from app.db.models.user import User
+from app.db.user_oper import UserOper
+from app.log import logger
+from app.schemas import AuthCredentials, AuthInterceptCredentials
+from app.schemas.types import ChainEventType
+from app.utils.otp import OtpUtils
+
+PASSWORD_INVALID_CREDENTIALS_MESSAGE = "用户名或密码或二次校验码不正确"
 
 
 class UserChain(ChainBase):
+    """
+    用户链，处理多种认证协议
+    """
 
-    def user_authenticate(self, name, password) -> Optional[str]:
+    def user_authenticate(
+            self,
+            username: Optional[str] = None,
+            password: Optional[str] = None,
+            mfa_code: Optional[str] = None,
+            code: Optional[str] = None,
+            grant_type: Optional[str] = "password"
+    ) -> Union[Tuple[bool, Optional[str]], Tuple[bool, Optional[User]]]:
         """
-        辅助完成用户认证
-        :param name: 用户名
-        :param password: 密码
-        :return: token
+        认证用户，根据不同的 grant_type 处理不同的认证流程
+
+        :param username: 用户名，适用于 "password" grant_type
+        :param password: 用户密码，适用于 "password" grant_type
+        :param mfa_code: 一次性密码，适用于 "password" grant_type
+        :param code: 授权码，适用于 "authorization_code" grant_type
+        :param grant_type: 认证类型，如 "password", "authorization_code", "client_credentials"
+        :return:
+            - 对于成功的认证，返回 (True, User)
+            - 对于失败的认证，返回 (False, "错误信息")
         """
-        return self.run_module("user_authenticate", name=name, password=password)
+        credentials = AuthCredentials(
+            username=username,
+            password=password,
+            mfa_code=mfa_code,
+            code=code,
+            grant_type=grant_type
+        )
+        logger.debug(f"认证类型：{grant_type}，开始准备对用户 {username} 进行身份校验")
+        if credentials.grant_type == "password":
+            # Password 认证
+            success, user_or_message = self.password_authenticate(credentials=credentials)
+            if success:
+                # 如果用户启用了二次验证码，则进一步验证
+                if not self._verify_mfa(user_or_message, credentials.mfa_code):
+                    return False, PASSWORD_INVALID_CREDENTIALS_MESSAGE
+                logger.info(f"用户 {username} 通过密码认证成功")
+                return True, user_or_message
+            else:
+                # 用户不存在或密码错误，考虑辅助认证
+                if settings.AUXILIARY_AUTH_ENABLE:
+                    logger.warning("密码认证失败，尝试通过外部服务进行辅助认证 ...")
+                    aux_success, aux_user_or_message = self.auxiliary_authenticate(credentials=credentials)
+                    if aux_success:
+                        # 辅助认证成功后再验证二次验证码
+                        if not self._verify_mfa(aux_user_or_message, credentials.mfa_code):
+                            return False, PASSWORD_INVALID_CREDENTIALS_MESSAGE
+                        return True, aux_user_or_message
+                    else:
+                        return False, PASSWORD_INVALID_CREDENTIALS_MESSAGE
+                else:
+                    logger.debug(f"辅助认证未启用，用户 {username} 认证失败")
+                    return False, PASSWORD_INVALID_CREDENTIALS_MESSAGE
+        elif credentials.grant_type == "authorization_code":
+            # 处理其他认证类型的分支
+            if settings.AUXILIARY_AUTH_ENABLE:
+                aux_success, aux_user_or_message = self.auxiliary_authenticate(credentials=credentials)
+                if aux_success:
+                    return True, aux_user_or_message
+                else:
+                    return False, "认证失败"
+            else:
+                return False, "认证失败"
+        else:
+            logger.debug(f"辅助认证未启用，认证类型 {grant_type} 未实现")
+            return False, "不支持的认证类型"
+
+    @staticmethod
+    def password_authenticate(credentials: AuthCredentials) -> Tuple[bool, Union[User, str]]:
+        """
+        密码认证
+
+        :param credentials: 认证凭证，包含用户名、密码以及可选的 MFA 认证码
+        :return:
+            - 成功时返回 (True, User)，其中 User 是认证通过的用户对象
+            - 失败时返回 (False, "错误信息")
+        """
+        if not credentials or credentials.grant_type != "password":
+            logger.info("密码认证失败，认证类型不匹配")
+            return False, PASSWORD_INVALID_CREDENTIALS_MESSAGE
+
+        user = UserOper().get_by_name(name=credentials.username)
+        if not user:
+            logger.info(f"密码认证失败，用户 {credentials.username} 不存在")
+            return False, PASSWORD_INVALID_CREDENTIALS_MESSAGE
+
+        if not user.is_active:
+            logger.info(f"密码认证失败，用户 {credentials.username} 已被禁用")
+            return False, PASSWORD_INVALID_CREDENTIALS_MESSAGE
+
+        if not verify_password(credentials.password, str(user.hashed_password)):
+            logger.info(f"密码认证失败，用户 {credentials.username} 的密码验证不通过")
+            return False, PASSWORD_INVALID_CREDENTIALS_MESSAGE
+
+        return True, user
+
+    def auxiliary_authenticate(self, credentials: AuthCredentials) -> Tuple[bool, Union[User, str]]:
+        """
+        辅助用户认证
+
+        :param credentials: 认证凭证，包含必要的认证信息
+        :return:
+            - 成功时返回 (True, User)，其中 User 是认证通过的用户对象
+            - 失败时返回 (False, "错误信息")
+        """
+        if not credentials:
+            return False, "认证凭证无效"
+
+        # 检查是否因为用户被禁用
+        useroper = UserOper()
+        if credentials.username:
+            user = useroper.get_by_name(name=credentials.username)
+            if user and not user.is_active:
+                logger.info(f"用户 {user.name} 已被禁用，跳过后续身份校验")
+                return False, PASSWORD_INVALID_CREDENTIALS_MESSAGE
+
+        logger.debug(f"认证类型：{credentials.grant_type}，尝试通过系统模块进行辅助认证，用户: {credentials.username}")
+        result = self.run_module("user_authenticate", credentials=credentials)
+
+        if not result:
+            logger.debug(f"通过系统模块辅助认证失败，尝试触发 {ChainEventType.AuthVerification} 事件")
+            event = self.eventmanager.send_event(etype=ChainEventType.AuthVerification, data=credentials)
+            if not event or not event.event_data:
+                logger.error(f"认证类型：{credentials.grant_type}，辅助认证失败，未返回有效数据")
+                return False, f"认证类型：{credentials.grant_type}，辅助认证事件失败或无效"
+
+            credentials = event.event_data  # 使用事件返回的认证数据
+        else:
+            logger.info(f"通过系统模块辅助认证成功，用户: {credentials.username}")
+            credentials = result  # 使用模块认证返回的认证数据
+
+        # 处理认证成功的逻辑
+        success = self._process_auth_success(username=credentials.username, credentials=credentials)
+        if success:
+            logger.info(f"用户 {credentials.username} 辅助认证通过")
+            return True, useroper.get_by_name(credentials.username)
+        else:
+            logger.warning(f"用户 {credentials.username} 辅助认证未通过")
+            return False, PASSWORD_INVALID_CREDENTIALS_MESSAGE
+
+    @staticmethod
+    def _verify_mfa(user: User, mfa_code: Optional[str]) -> bool:
+        """
+        验证 MFA（二次验证码）
+
+        :param user: 用户对象
+        :param mfa_code: 二次验证码
+        :return: 如果验证成功返回 True，否则返回 False
+        """
+        if not user.is_otp:
+            return True
+        if not mfa_code:
+            logger.info(f"用户 {user.name} 缺少 MFA 认证码")
+            return False
+        if not OtpUtils.check(str(user.otp_secret), mfa_code):
+            logger.info(f"用户 {user.name} 的 MFA 认证失败")
+            return False
+        return True
+
+    def _process_auth_success(self, username: str, credentials: AuthCredentials) -> bool:
+        """
+        处理辅助认证成功的逻辑，返回用户对象或创建新用户
+
+        :param username: 用户名
+        :param credentials: 认证凭证，包含 token、channel、service 等信息
+        :return:
+            - 如果认证成功并且用户存在或已创建，返回 User 对象
+            - 如果认证被拦截或失败，返回 None
+        """
+        if not username:
+            logger.info(f"未能获取到对应的用户信息，{credentials.grant_type} 认证不通过")
+            return False
+
+        token, channel, service = credentials.token, credentials.channel, credentials.service
+        if not all([token, channel, service]):
+            logger.info(f"用户 {username} 未通过 {credentials.grant_type} 认证，必要信息不足")
+            return False
+
+        # 触发认证通过的拦截事件
+        intercept_event = self.eventmanager.send_event(
+            etype=ChainEventType.AuthIntercept,
+            data=AuthInterceptCredentials(username=username, channel=channel, service=service,
+                                          token=token, status="completed")
+        )
+        if intercept_event and intercept_event.event_data:
+            intercept_data: AuthInterceptCredentials = intercept_event.event_data
+            if intercept_data.cancel:
+                logger.warning(
+                    f"认证被拦截，用户：{username}，渠道：{channel}，服务：{service}，拦截源：{intercept_data.source}")
+                return False
+
+        # 检查用户是否存在，如果不存在且当前为密码认证时则创建新用户
+        useroper = UserOper()
+        user = useroper.get_by_name(name=username)
+        if user:
+            # 如果用户存在，但是已经被禁用，则直接响应
+            if not user.is_active:
+                logger.info(f"辅助认证失败，用户 {username} 已被禁用")
+                return False
+            anonymized_token = f"{token[:len(token) // 2]}********"
+            logger.info(
+                f"认证类型：{credentials.grant_type}，用户：{username}，渠道：{channel}，"
+                f"服务：{service} 认证成功，token：{anonymized_token}")
+            return True
+        else:
+            if credentials.grant_type == "password":
+                useroper.add(name=username, is_active=True, is_superuser=False,
+                             hashed_password=get_password_hash(secrets.token_urlsafe(16)))
+                logger.info(f"用户 {username} 不存在，已通过 {credentials.grant_type} 认证并已创建普通用户")
+                return True
+            else:
+                logger.warning(
+                    f"认证类型：{credentials.grant_type}，用户：{username}，渠道：{channel}，"
+                    f"服务：{service} 认证不通过，未能在本地找到对应的用户信息")
+                return False

app/chain/webhook.py

@@ -1,10 +1,7 @@
-import time
 from typing import Any
 
 from app.chain import ChainBase
-from app.schemas import Notification
-from app.schemas.types import EventType, MediaImageType, MediaType, NotificationType
-from app.utils.web import WebUtils
+from app.schemas.types import EventType
 
 
 class WebhookChain(ChainBase):
@@ -14,7 +11,7 @@ class WebhookChain(ChainBase):
 
     def message(self, body: Any, form: Any, args: Any) -> None:
         """
-        处理Webhook报文并发送消息
+        处理Webhook报文并发送事件
         """
         # 获取主体内容
         event_info = self.webhook_parser(body=body, form=form, args=args)
@@ -22,76 +19,3 @@ class WebhookChain(ChainBase):
             return
         # 广播事件
         self.eventmanager.send_event(EventType.WebhookMessage, event_info)
-        # 拼装消息内容
-        _webhook_actions = {
-            "library.new": "新入库",
-            "system.webhooktest": "测试",
-            "playback.start": "开始播放",
-            "playback.stop": "停止播放",
-            "user.authenticated": "登录成功",
-            "user.authenticationfailed": "登录失败",
-            "media.play": "开始播放",
-            "media.stop": "停止播放",
-            "PlaybackStart": "开始播放",
-            "PlaybackStop": "停止播放",
-            "item.rate": "标记了"
-        }
-        _webhook_images = {
-            "emby": "https://emby.media/notificationicon.png",
-            "plex": "https://www.plex.tv/wp-content/uploads/2022/04/new-logo-process-lines-gray.png",
-            "jellyfin": "https://play-lh.googleusercontent.com/SCsUK3hCCRqkJbmLDctNYCfehLxsS4ggD1ZPHIFrrAN1Tn9yhjmGMPep2D9lMaaa9eQi"
-        }
-
-        if not _webhook_actions.get(event_info.event):
-            return
-
-        # 消息标题
-        if event_info.item_type in ["TV", "SHOW"]:
-            message_title = f"{_webhook_actions.get(event_info.event)}剧集 {event_info.item_name}"
-        elif event_info.item_type == "MOV":
-            message_title = f"{_webhook_actions.get(event_info.event)}电影 {event_info.item_name}"
-        elif event_info.item_type == "AUD":
-            message_title = f"{_webhook_actions.get(event_info.event)}有声书 {event_info.item_name}"
-        else:
-            message_title = f"{_webhook_actions.get(event_info.event)}"
-
-        # 消息内容
-        message_texts = []
-        if event_info.user_name:
-            message_texts.append(f"用户：{event_info.user_name}")
-        if event_info.device_name:
-            message_texts.append(f"设备：{event_info.client} {event_info.device_name}")
-        if event_info.ip:
-            message_texts.append(f"IP地址：{event_info.ip} {WebUtils.get_location(event_info.ip)}")
-        if event_info.percentage:
-            percentage = round(float(event_info.percentage), 2)
-            message_texts.append(f"进度：{percentage}%")
-        if event_info.overview:
-            message_texts.append(f"剧情：{event_info.overview}")
-        message_texts.append(f"时间：{time.strftime('%Y-%m-%d %H:%M:%S', time.localtime(time.time()))}")
-
-        # 消息内容
-        message_content = "\n".join(message_texts)
-
-        # 消息图片
-        image_url = event_info.image_url
-        # 查询剧集图片
-        if (event_info.tmdb_id
-                and event_info.season_id
-                and event_info.episode_id):
-            specific_image = self.obtain_specific_image(
-                mediaid=event_info.tmdb_id,
-                mtype=MediaType.TV,
-                image_type=MediaImageType.Backdrop,
-                season=event_info.season_id,
-                episode=event_info.episode_id
-            )
-            if specific_image:
-                image_url = specific_image
-        # 使用默认图片
-        if not image_url:
-            image_url = _webhook_images.get(event_info.channel)
-
-        # 发送消息
-        self.post_message(Notification(mtype=NotificationType.MediaServer,
-                                       title=message_title, text=message_content, image=image_url))

app/chain/workflow.py

@@ -0,0 +1,249 @@
+import base64
+import pickle
+import threading
+from collections import defaultdict, deque
+from concurrent.futures import ThreadPoolExecutor
+from time import sleep
+from typing import List, Tuple, Optional
+
+from pydantic.fields import Callable
+
+from app.chain import ChainBase
+from app.core.config import global_vars
+from app.core.workflow import WorkFlowManager
+from app.db.models import Workflow
+from app.db.workflow_oper import WorkflowOper
+from app.log import logger
+from app.schemas import ActionContext, ActionFlow, Action, ActionExecution
+
+
+class WorkflowExecutor:
+    """
+    工作流执行器
+    """
+
+    def __init__(self, workflow: Workflow, step_callback: Callable = None):
+        """
+        初始化工作流执行器
+        :param workflow: 工作流对象
+        :param step_callback: 步骤回调函数
+        """
+        # 工作流数据
+        self.workflow = workflow
+        self.step_callback = step_callback
+        self.actions = {action['id']: Action(**action) for action in workflow.actions}
+        self.flows = [ActionFlow(**flow) for flow in workflow.flows]
+        self.total_actions = len(self.actions)
+        self.finished_actions = 0
+
+        self.success = True
+        self.errmsg = ""
+
+        # 工作流管理器
+        self.workflowmanager = WorkFlowManager()
+        # 线程安全队列
+        self.queue = deque()
+        # 锁用于保证线程安全
+        self.lock = threading.Lock()
+        # 线程池
+        self.executor = ThreadPoolExecutor()
+        # 跟踪运行中的任务数
+        self.running_tasks = 0
+
+        # 构建邻接表、入度表
+        self.adjacency = defaultdict(list)
+        self.indegree = defaultdict(int)
+        for flow in self.flows:
+            source = flow.source
+            target = flow.target
+            self.adjacency[source].append(target)
+            self.indegree[target] += 1
+
+        # 初始化所有节点的入度（确保未被引用的节点入度为0）
+        for action_id in self.actions:
+            if action_id not in self.indegree:
+                self.indegree[action_id] = 0
+
+        # 初始上下文
+        if workflow.current_action and workflow.context:
+            logger.info(f"工作流已执行动作：{workflow.current_action}")
+            # Base64解码
+            decoded_data = base64.b64decode(workflow.context["content"])
+            # 反序列化数据
+            self.context = pickle.loads(decoded_data)
+        else:
+            self.context = ActionContext()
+
+        # 恢复工作流
+        global_vars.workflow_resume(self.workflow.id)
+        # 初始化队列，添加入度为0的节点
+        for action_id in self.actions:
+            if self.indegree[action_id] == 0:
+                self.queue.append(action_id)
+
+    def execute(self):
+        """
+        执行工作流
+        """
+        while True:
+            with self.lock:
+                # 退出条件：队列为空且无运行任务
+                if not self.queue and self.running_tasks == 0:
+                    break
+                # 退出条件：出现了错误
+                if not self.success:
+                    break
+                if not self.queue:
+                    sleep(0.1)
+                    continue
+                # 取出队首节点
+                node_id = self.queue.popleft()
+                # 标记任务开始
+                self.running_tasks += 1
+
+            # 已停机
+            if global_vars.is_workflow_stopped(self.workflow.id):
+                global_vars.workflow_resume(self.workflow.id)
+                break
+
+            # 已执行的跳过
+            if (self.workflow.current_action
+                    and node_id in self.workflow.current_action.split(',')):
+                continue
+
+            # 提交任务到线程池
+            future = self.executor.submit(
+                self.execute_node,
+                self.workflow.id,
+                node_id,
+                self.context
+            )
+            future.add_done_callback(self.on_node_complete)
+
+    def execute_node(self, workflow_id: int, node_id: int,
+                     context: ActionContext) -> Tuple[Action, bool, str, ActionContext]:
+        """
+        执行单个节点操作，返回修改后的上下文和节点ID
+        """
+        action = self.actions[node_id]
+        state, message, result_ctx = self.workflowmanager.excute(workflow_id, action, context=context)
+        return action, state, message, result_ctx
+
+    def on_node_complete(self, future):
+        """
+        节点完成回调：更新上下文、处理后继节点
+        """
+        action, state, message, result_ctx = future.result()
+
+        try:
+            self.finished_actions += 1
+            # 更新当前进度
+            self.context.progress = round(self.finished_actions / self.total_actions) * 100
+
+            # 补充执行历史
+            self.context.execute_history.append(
+                ActionExecution(
+                    action=action.name,
+                    result=state,
+                    message=message
+                )
+            )
+
+            # 节点执行失败
+            if not state:
+                self.success = False
+                self.errmsg = f"{action.name} 失败"
+                return
+
+            with self.lock:
+                # 更新主上下文
+                self.merge_context(result_ctx)
+                # 回调
+                if self.step_callback:
+                    self.step_callback(action, self.context)
+
+            # 处理后继节点
+            successors = self.adjacency.get(action.id, [])
+            for succ_id in successors:
+                with self.lock:
+                    self.indegree[succ_id] -= 1
+                    if self.indegree[succ_id] == 0:
+                        self.queue.append(succ_id)
+        finally:
+            # 标记任务完成
+            with self.lock:
+                self.running_tasks -= 1
+
+    def merge_context(self, context: ActionContext):
+        """
+        合并上下文
+        """
+        for key, value in context.dict().items():
+            if not getattr(self.context, key, None):
+                setattr(self.context, key, value)
+
+
+class WorkflowChain(ChainBase):
+    """
+    工作流链
+    """
+
+    @staticmethod
+    def process(workflow_id: int, from_begin: Optional[bool] = True) -> Tuple[bool, str]:
+        """
+        处理工作流
+        :param workflow_id: 工作流ID
+        :param from_begin: 是否从头开始，默认为True
+        """
+        workflowoper = WorkflowOper()
+
+        def save_step(action: Action, context: ActionContext):
+            """
+            保存上下文到数据库
+            """
+            # 序列化数据
+            serialized_data = pickle.dumps(context)
+            # 使用Base64编码字节流
+            encoded_data = base64.b64encode(serialized_data).decode('utf-8')
+            workflowoper.step(workflow_id, action_id=action.id, context={
+                "content": encoded_data
+            })
+
+        # 重置工作流
+        if from_begin:
+            workflowoper.reset(workflow_id)
+
+        # 查询工作流数据
+        workflow = workflowoper.get(workflow_id)
+        if not workflow:
+            logger.warn(f"工作流 {workflow_id} 不存在")
+            return False, "工作流不存在"
+        if not workflow.actions:
+            logger.warn(f"工作流 {workflow.name} 无动作")
+            return False, "工作流无动作"
+        if not workflow.flows:
+            logger.warn(f"工作流 {workflow.name} 无流程")
+            return False, "工作流无流程"
+
+        logger.info(f"开始处理 {workflow.name}，共 {len(workflow.actions)} 个动作 ...")
+        workflowoper.start(workflow_id)
+
+        # 执行工作流
+        executor = WorkflowExecutor(workflow, step_callback=save_step)
+        executor.execute()
+
+        if not executor.success:
+            logger.info(f"工作流 {workflow.name} 执行失败：{executor.errmsg}")
+            workflowoper.fail(workflow_id, result=executor.errmsg)
+            return False, executor.errmsg
+        else:
+            logger.info(f"工作流 {workflow.name} 执行完成")
+            workflowoper.success(workflow_id)
+            return True, ""
+
+    @staticmethod
+    def get_workflows() -> List[Workflow]:
+        """
+        获取工作流列表
+        """
+        return WorkflowOper().list_enabled()

app/command.py

@@ -1,6 +1,7 @@
+import copy
+import threading
 import traceback
-from threading import Thread, Event
-from typing import Any, Union, Dict
+from typing import Any, Union, Dict, Optional
 
 from app.chain import ChainBase
 from app.chain.download import DownloadChain
@@ -8,51 +9,37 @@ from app.chain.site import SiteChain
 from app.chain.subscribe import SubscribeChain
 from app.chain.system import SystemChain
 from app.chain.transfer import TransferChain
-from app.core.event import Event as ManagerEvent
-from app.core.event import eventmanager, EventManager
+from app.core.event import Event as ManagerEvent, eventmanager, Event
 from app.core.plugin import PluginManager
-from app.db import SessionFactory
+from app.helper.message import MessageHelper
+from app.helper.thread import ThreadHelper
 from app.log import logger
 from app.scheduler import Scheduler
-from app.schemas import Notification
-from app.schemas.types import EventType, MessageChannel
+from app.schemas import Notification, CommandRegisterEventData
+from app.schemas.types import EventType, MessageChannel, ChainEventType
 from app.utils.object import ObjectUtils
 from app.utils.singleton import Singleton
-from app.utils.system import SystemUtils
+from app.utils.structures import DictUtils
 
 
-class CommandChian(ChainBase):
-    """
-    插件处理链
-    """
-
-    def process(self, *args, **kwargs):
-        pass
+class CommandChain(ChainBase):
+    pass
 
 
 class Command(metaclass=Singleton):
     """
     全局命令管理，消费事件
     """
-    # 内建命令
-    _commands = {}
-
-    # 退出事件
-    _event = Event()
 
     def __init__(self):
-        # 数据库连接
-        self._db = SessionFactory()
-        # 事件管理器
-        self.eventmanager = EventManager()
         # 插件管理器
-        self.pluginmanager = PluginManager()
-        # 处理链
-        self.chain = CommandChian(self._db)
-        # 定时服务管理
-        self.scheduler = Scheduler()
-        # 内置命令
-        self._commands = {
+        super().__init__()
+        # 注册的命令集合
+        self._registered_commands = {}
+        # 所有命令集合
+        self._commands = {}
+        # 内建命令集合
+        self._preset_commands = {
             "/cookiecloud": {
                 "id": "cookiecloud",
                 "type": "scheduler",
@@ -60,23 +47,28 @@ class Command(metaclass=Singleton):
                 "category": "站点"
             },
             "/sites": {
-                "func": SiteChain(self._db).remote_list,
+                "func": SiteChain().remote_list,
                 "description": "查询站点",
                 "category": "站点",
                 "data": {}
             },
             "/site_cookie": {
-                "func": SiteChain(self._db).remote_cookie,
+                "func": SiteChain().remote_cookie,
                 "description": "更新站点Cookie",
                 "data": {}
             },
+            "/site_statistic": {
+                "func": SiteChain().remote_refresh_userdatas,
+                "description": "站点数据统计",
+                "data": {}
+            },
             "/site_enable": {
-                "func": SiteChain(self._db).remote_enable,
+                "func": SiteChain().remote_enable,
                 "description": "启用站点",
                 "data": {}
             },
             "/site_disable": {
-                "func": SiteChain(self._db).remote_disable,
+                "func": SiteChain().remote_disable,
                 "description": "禁用站点",
                 "data": {}
             },
@@ -87,7 +79,7 @@ class Command(metaclass=Singleton):
                 "category": "管理"
             },
             "/subscribes": {
-                "func": SubscribeChain(self._db).remote_list,
+                "func": SubscribeChain().remote_list,
                 "description": "查询订阅",
                 "category": "订阅",
                 "data": {}
@@ -105,7 +97,7 @@ class Command(metaclass=Singleton):
                 "category": "订阅"
             },
             "/subscribe_delete": {
-                "func": SubscribeChain(self._db).remote_delete,
+                "func": SubscribeChain().remote_delete,
                 "description": "删除订阅",
                 "data": {}
             },
@@ -115,7 +107,7 @@ class Command(metaclass=Singleton):
                 "description": "订阅元数据更新"
             },
             "/downloading": {
-                "func": DownloadChain(self._db).remote_downloading,
+                "func": DownloadChain().remote_downloading,
                 "description": "正在下载",
                 "category": "管理",
                 "data": {}
@@ -127,73 +119,167 @@ class Command(metaclass=Singleton):
                 "category": "管理"
             },
             "/redo": {
-                "func": TransferChain(self._db).remote_transfer,
+                "func": TransferChain().remote_transfer,
                 "description": "手动整理",
                 "data": {}
             },
             "/clear_cache": {
-                "func": SystemChain(self._db).remote_clear_cache,
+                "func": SystemChain().remote_clear_cache,
                 "description": "清理缓存",
                 "category": "管理",
                 "data": {}
             },
             "/restart": {
-                "func": SystemUtils.restart,
+                "func": SystemChain().restart,
                 "description": "重启系统",
                 "category": "管理",
                 "data": {}
+            },
+            "/version": {
+                "func": SystemChain().version,
+                "description": "当前版本",
+                "category": "管理",
+                "data": {}
             }
         }
-        # 汇总插件命令
-        plugin_commands = self.pluginmanager.get_plugin_commands()
-        for command in plugin_commands:
-            self.register(
-                cmd=command.get('cmd'),
-                func=Command.send_plugin_event,
-                desc=command.get('desc'),
-                category=command.get('category'),
-                data={
-                    'etype': command.get('event'),
-                    'data': command.get('data')
+        # 插件命令集合
+        self._plugin_commands = {}
+        # 其他命令集合
+        self._other_commands = {}
+        # 初始化锁
+        self._rlock = threading.RLock()
+        # 插件管理
+        self.pluginmanager = PluginManager()
+        # 定时服务管理
+        self.scheduler = Scheduler()
+        # 消息管理器
+        self.messagehelper = MessageHelper()
+        # 初始化命令
+        self.init_commands()
+
+    def init_commands(self, pid: Optional[str] = None) -> None:
+        """
+        初始化菜单命令
+        """
+        # 使用线程池提交后台任务，避免引起阻塞
+        ThreadHelper().submit(self.__init_commands_background, pid)
+
+    def __init_commands_background(self, pid: Optional[str] = None) -> None:
+        """
+        后台初始化菜单命令
+        """
+        try:
+            with self._rlock:
+                logger.debug("Acquired lock for initializing commands in background.")
+                self._plugin_commands = self.__build_plugin_commands(pid)
+                self._commands = {
+                    **self._preset_commands,
+                    **self._plugin_commands,
+                    **self._other_commands
                 }
-            )
-        # 广播注册命令菜单
-        self.chain.register_commands(commands=self.get_commands())
-        # 消息处理线程
-        self._thread = Thread(target=self.__run)
-        # 启动事件处理线程
-        self._thread.start()
 
-    def __run(self):
-        """
-        事件处理线程
-        """
-        while not self._event.is_set():
-            event, handlers = self.eventmanager.get_event()
-            if event:
-                logger.info(f"处理事件：{event.event_type} - {handlers}")
-                for handler in handlers:
-                    try:
-                        names = handler.__qualname__.split(".")
-                        if names[0] == "Command":
-                            self.command_event(event)
-                        else:
-                            self.pluginmanager.run_plugin_method(names[0], names[1], event)
-                    except Exception as e:
-                        logger.error(f"事件处理出错：{str(e)} - {traceback.format_exc()}")
+                # 强制触发注册
+                force_register = False
+                # 触发事件允许可以拦截和调整命令
+                event, initial_commands = self.__trigger_register_commands_event()
 
-    def __run_command(self, command: Dict[str, any],
-                      data_str: str = "",
-                      channel: MessageChannel = None, userid: Union[str, int] = None):
+                if event and event.event_data:
+                    # 如果事件返回有效的 event_data，使用事件中调整后的命令
+                    event_data: CommandRegisterEventData = event.event_data
+                    # 如果事件被取消，跳过命令注册
+                    if event_data.cancel:
+                        logger.debug(f"Command initialization canceled by event: {event_data.source}")
+                        return
+                    # 如果拦截源与插件标识一致时，这里认为需要强制触发注册
+                    if pid is not None and pid == event_data.source:
+                        force_register = True
+                    initial_commands = event_data.commands or {}
+                    logger.debug(f"Registering command count from event: {len(initial_commands)}")
+                else:
+                    logger.debug(f"Registering initial command count: {len(initial_commands)}")
+
+                # initial_commands 必须是 self._commands 的子集
+                filtered_initial_commands = DictUtils.filter_keys_to_subset(initial_commands, self._commands)
+                # 如果 filtered_initial_commands 为空，则跳过注册
+                if not filtered_initial_commands and not force_register:
+                    logger.debug("Filtered commands are empty, skipping registration.")
+                    return
+
+                # 对比调整后的命令与当前命令
+                if filtered_initial_commands != self._registered_commands or force_register:
+                    logger.debug("Command set has changed or force registration is enabled.")
+                    self._registered_commands = filtered_initial_commands
+                    CommandChain().register_commands(commands=filtered_initial_commands)
+                else:
+                    logger.debug("Command set unchanged, skipping broadcast registration.")
+        except Exception as e:
+            logger.error(f"Error occurred during command initialization in background: {e}", exc_info=True)
+
+    def __trigger_register_commands_event(self) -> (Optional[Event], dict):
+        """
+        触发事件，允许调整命令数据
+        """
+
+        def add_commands(source, command_type):
+            """
+            添加命令集合
+            """
+            for cmd, command in source.items():
+                command_data = {
+                    "type": command_type,
+                    "description": command.get("description"),
+                    "category": command.get("category")
+                }
+                # 如果有 pid，则添加到命令数据中
+                plugin_id = command.get("pid")
+                if plugin_id:
+                    command_data["pid"] = plugin_id
+                commands[cmd] = command_data
+
+        # 初始化命令字典
+        commands: Dict[str, dict] = {}
+        add_commands(self._preset_commands, "preset")
+        add_commands(self._plugin_commands, "plugin")
+        add_commands(self._other_commands, "other")
+
+        # 触发事件允许可以拦截和调整命令
+        event_data = CommandRegisterEventData(commands=commands, origin="CommandChain", service=None)
+        event = eventmanager.send_event(ChainEventType.CommandRegister, event_data)
+        return event, commands
+
+    def __build_plugin_commands(self, _: Optional[str] = None) -> Dict[str, dict]:
+        """
+        构建插件命令
+        """
+        # 为了保证命令顺序的一致性，目前这里没有直接使用 pid 获取单一插件命令，后续如果存在性能问题，可以考虑优化这里的逻辑
+        plugin_commands = {}
+        for command in self.pluginmanager.get_plugin_commands():
+            cmd = command.get("cmd")
+            if cmd:
+                plugin_commands[cmd] = {
+                    "pid": command.get("pid"),
+                    "func": self.send_plugin_event,
+                    "description": command.get("desc"),
+                    "category": command.get("category"),
+                    "data": {
+                        "etype": command.get("event"),
+                        "data": command.get("data")
+                    }
+                }
+        return plugin_commands
+
+    def __run_command(self, command: Dict[str, any], data_str: Optional[str] = "",
+                      channel: MessageChannel = None, source: Optional[str] = None, userid: Union[str, int] = None):
         """
         运行定时服务
         """
         if command.get("type") == "scheduler":
             # 定时服务
             if userid:
-                self.chain.post_message(
+                CommandChain().post_message(
                     Notification(
                         channel=channel,
+                        source=source,
                         title=f"开始执行 {command.get('description')} ...",
                         userid=userid
                     )
@@ -203,70 +289,67 @@ class Command(metaclass=Singleton):
             self.scheduler.start(job_id=command.get("id"))
 
             if userid:
-                self.chain.post_message(
+                CommandChain().post_message(
                     Notification(
                         channel=channel,
+                        source=source,
                         title=f"{command.get('description')} 执行完成",
                         userid=userid
                     )
                 )
         else:
             # 命令
-            cmd_data = command['data'] if command.get('data') else {}
+            cmd_data = copy.deepcopy(command['data']) if command.get('data') else {}
             args_num = ObjectUtils.arguments(command['func'])
             if args_num > 0:
                 if cmd_data:
                     # 有内置参数直接使用内置参数
                     data = cmd_data.get("data") or {}
                     data['channel'] = channel
+                    data['source'] = source
                     data['user'] = userid
+                    if data_str:
+                        data['arg_str'] = data_str
                     cmd_data['data'] = data
                     command['func'](**cmd_data)
-                elif args_num == 2:
-                    # 没有输入参数，只输入渠道和用户ID
-                    command['func'](channel, userid)
-                elif args_num > 2:
+                elif args_num == 3:
+                    # 没有输入参数，只输入渠道来源、用户ID和消息来源
+                    command['func'](channel, userid, source)
+                elif args_num > 3:
                     # 多个输入参数：用户输入、用户ID
-                    command['func'](data_str, channel, userid)
+                    command['func'](data_str, channel, userid, source)
             else:
                 # 没有参数
                 command['func']()
 
-    def stop(self):
-        """
-        停止事件处理线程
-        """
-        self._event.set()
-        self._thread.join()
-        if self._db:
-            self._db.close()
-
     def get_commands(self):
         """
         获取命令列表
         """
         return self._commands
 
-    def register(self, cmd: str, func: Any, data: dict = None,
-                 desc: str = None, category: str = None) -> None:
-        """
-        注册命令
-        """
-        self._commands[cmd] = {
-            "func": func,
-            "description": desc,
-            "category": category,
-            "data": data or {}
-        }
-
     def get(self, cmd: str) -> Any:
         """
         获取命令
         """
         return self._commands.get(cmd, {})
 
-    def execute(self, cmd: str, data_str: str = "",
-                channel: MessageChannel = None, userid: Union[str, int] = None) -> None:
+    def register(self, cmd: str, func: Any, data: Optional[dict] = None,
+                 desc: Optional[str] = None, category: Optional[str] = None) -> None:
+        """
+        注册单个命令
+        """
+        # 单独调用的，统一注册到其他
+        self._other_commands[cmd] = {
+            "func": func,
+            "description": desc,
+            "category": category,
+            "data": data or {}
+        }
+
+    def execute(self, cmd: str, data_str: Optional[str] = "",
+                channel: MessageChannel = None, source: Optional[str] = None,
+                userid: Union[str, int] = None) -> None:
         """
         执行命令
         """
@@ -280,22 +363,24 @@ class Command(metaclass=Singleton):
 
                 # 执行命令
                 self.__run_command(command, data_str=data_str,
-                                   channel=channel, userid=userid)
+                                   channel=channel, source=source, userid=userid)
 
                 if userid:
                     logger.info(f"用户 {userid} {command.get('description')} 执行完成")
                 else:
                     logger.info(f"{command.get('description')} 执行完成")
             except Exception as err:
-                logger.error(f"执行命令 {cmd} 出错：{str(err)}")
-                traceback.print_exc()
+                logger.error(f"执行命令 {cmd} 出错：{str(err)} - {traceback.format_exc()}")
+                self.messagehelper.put(title=f"执行命令 {cmd} 出错",
+                                       message=str(err),
+                                       role="system")
 
     @staticmethod
     def send_plugin_event(etype: EventType, data: dict) -> None:
         """
         发送插件命令
         """
-        EventManager().send_event(etype, data)
+        eventmanager.send_event(etype, data)
 
     @eventmanager.register(EventType.CommandExcute)
     def command_event(self, event: ManagerEvent) -> None:
@@ -309,10 +394,21 @@ class Command(metaclass=Singleton):
         event_str = event.event_data.get('cmd')
         # 消息渠道
         event_channel = event.event_data.get('channel')
+        # 消息来源
+        event_source = event.event_data.get('source')
         # 消息用户
         event_user = event.event_data.get('user')
         if event_str:
             cmd = event_str.split()[0]
             args = " ".join(event_str.split()[1:])
             if self.get(cmd):
-                self.execute(cmd, args, event_channel, event_user)
+                self.execute(cmd=cmd, data_str=args,
+                             channel=event_channel, source=event_source, userid=event_user)
+
+    @eventmanager.register(EventType.ModuleReload)
+    def module_reload_event(self, _: ManagerEvent) -> None:
+        """
+        注册模块重载事件
+        """
+        # 发生模块重载时，重新注册命令
+        self.init_commands()

app/core/cache.py

@@ -0,0 +1,576 @@
+import inspect
+import json
+import pickle
+import threading
+from abc import ABC, abstractmethod
+from functools import wraps
+from typing import Any, Dict, Optional
+from urllib.parse import quote
+
+import redis
+from cachetools import TTLCache
+from cachetools.keys import hashkey
+
+from app.core.config import settings
+from app.log import logger
+
+# 默认缓存区
+DEFAULT_CACHE_REGION = "DEFAULT"
+
+lock = threading.Lock()
+
+
+class CacheBackend(ABC):
+    """
+    缓存后端基类，定义通用的缓存接口
+    """
+
+    @abstractmethod
+    def set(self, key: str, value: Any, ttl: int, region: Optional[str] = DEFAULT_CACHE_REGION, **kwargs) -> None:
+        """
+        设置缓存
+
+        :param key: 缓存的键
+        :param value: 缓存的值
+        :param ttl: 缓存的存活时间，单位秒
+        :param region: 缓存的区
+        :param kwargs: 其他参数
+        """
+        pass
+
+    @abstractmethod
+    def exists(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> bool:
+        """
+        判断缓存键是否存在
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 存在返回 True，否则返回 False
+        """
+        pass
+
+    @abstractmethod
+    def get(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> Any:
+        """
+        获取缓存
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 返回缓存的值，如果缓存不存在返回 None
+        """
+        pass
+
+    @abstractmethod
+    def delete(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> None:
+        """
+        删除缓存
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        """
+        pass
+
+    @abstractmethod
+    def clear(self, region: Optional[str] = None) -> None:
+        """
+        清除指定区域的缓存或全部缓存
+
+        :param region: 缓存的区
+        """
+        pass
+
+    @abstractmethod
+    def close(self) -> None:
+        """
+        关闭缓存连接
+        """
+        pass
+
+    @staticmethod
+    def get_region(region: Optional[str] = DEFAULT_CACHE_REGION):
+        """
+        获取缓存的区
+        """
+        return f"region:{region}" if region else "region:default"
+
+    @staticmethod
+    def get_cache_key(func, args, kwargs):
+        """
+        获取缓存的键，通过哈希函数对函数的参数进行处理
+        :param func: 被装饰的函数
+        :param args: 位置参数
+        :param kwargs: 关键字参数
+        :return: 缓存键
+        """
+        signature = inspect.signature(func)
+        # 绑定传入的参数并应用默认值
+        bound = signature.bind(*args, **kwargs)
+        bound.apply_defaults()
+        # 忽略第一个参数，如果它是实例(self)或类(cls)
+        parameters = list(signature.parameters.keys())
+        if parameters and parameters[0] in ("self", "cls"):
+            bound.arguments.pop(parameters[0], None)
+        # 按照函数签名顺序提取参数值列表
+        keys = [
+            bound.arguments[param] for param in signature.parameters if param in bound.arguments
+        ]
+        # 使用有序参数生成缓存键
+        return f"{func.__name__}_{hashkey(*keys)}"
+
+
+class CacheToolsBackend(CacheBackend):
+    """
+    基于 `cachetools.TTLCache` 实现的缓存后端
+
+    特性：
+    - 支持动态设置缓存的 TTL（Time To Live，存活时间）和最大条目数（Maxsize）
+    - 缓存实例按区域（region）划分，不同 region 拥有独立的缓存实例
+    - 同一 region 共享相同的 TTL 和 Maxsize，设置时只能作用于整个 region
+
+    限制：
+    - 不支持按 `key` 独立隔离 TTL 和 Maxsize，仅支持作用于 region 级别
+    """
+
+    def __init__(self, maxsize: Optional[int] = 512, ttl: Optional[int] = 1800):
+        """
+        初始化缓存实例
+
+        :param maxsize: 缓存的最大条目数
+        :param ttl: 默认缓存存活时间，单位秒
+        """
+        self.maxsize = maxsize
+        self.ttl = ttl
+        # 存储各个 region 的缓存实例，region -> TTLCache
+        self._region_caches: Dict[str, TTLCache] = {}
+
+    def __get_region_cache(self, region: str) -> Optional[TTLCache]:
+        """
+        获取指定区域的缓存实例，如果不存在则返回 None
+        """
+        region = self.get_region(region)
+        return self._region_caches.get(region)
+
+    def set(self, key: str, value: Any, ttl: Optional[int] = None, 
+            region: Optional[str] = DEFAULT_CACHE_REGION, **kwargs) -> None:
+        """
+        设置缓存值支持每个 key 独立配置 TTL 和 Maxsize
+
+        :param key: 缓存的键
+        :param value: 缓存的值
+        :param ttl: 缓存的存活时间，单位秒如果未传入则使用默认值
+        :param region: 缓存的区
+        :param kwargs: maxsize: 缓存的最大条目数如果未传入则使用默认值
+        """
+        ttl = ttl or self.ttl
+        maxsize = kwargs.get("maxsize", self.maxsize)
+        region = self.get_region(region)
+        # 如果该 key 尚未有缓存实例，则创建一个新的 TTLCache 实例
+        region_cache = self._region_caches.setdefault(region, TTLCache(maxsize=maxsize, ttl=ttl))
+        # 设置缓存值
+        with lock:
+            region_cache[key] = value
+
+    def exists(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> bool:
+        """
+        判断缓存键是否存在
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 存在返回 True，否则返回 False
+        """
+        region_cache = self.__get_region_cache(region)
+        if region_cache is None:
+            return False
+        return key in region_cache
+
+    def get(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> Any:
+        """
+        获取缓存的值
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 返回缓存的值，如果缓存不存在返回 None
+        """
+        region_cache = self.__get_region_cache(region)
+        if region_cache is None:
+            return None
+        return region_cache.get(key)
+
+    def delete(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION):
+        """
+        删除缓存
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        """
+        region_cache = self.__get_region_cache(region)
+        if region_cache is None:
+            return
+        with lock:
+            del region_cache[key]
+
+    def clear(self, region: Optional[str] = None) -> None:
+        """
+        清除指定区域的缓存或全部缓存
+
+        :param region: 缓存的区
+        """
+        if region:
+            # 清理指定缓存区
+            region_cache = self.__get_region_cache(region)
+            if region_cache:
+                with lock:
+                    region_cache.clear()
+                logger.info(f"Cleared cache for region: {region}")
+        else:
+            # 清除所有区域的缓存
+            for region_cache in self._region_caches.values():
+                with lock:
+                    region_cache.clear()
+            logger.info("Cleared all cache")
+
+    def close(self) -> None:
+        """
+        内存缓存不需要关闭资源
+        """
+        pass
+
+
+class RedisBackend(CacheBackend):
+    """
+    基于 Redis 实现的缓存后端，支持通过 Redis 存储缓存
+
+    特性：
+    - 支持动态设置缓存的 TTL（Time To Live，存活时间）
+    - 支持分区域（region）管理缓存，不同的 region 采用独立的命名空间
+    - 支持自定义最大内存限制（maxmemory）和内存淘汰策略（如 allkeys-lru）
+
+    限制：
+    - 由于 Redis 的分布式特性，写入和读取可能受到网络延迟的影响
+    - Pickle 反序列化可能存在安全风险，需进一步重构调用来源，避免复杂对象缓存
+    """
+
+    # 类型缓存集合，针对非容器简单类型
+    _complex_serializable_types = set()
+    _simple_serializable_types = set()
+
+    def __init__(self, redis_url: Optional[str] = "redis://localhost", ttl: Optional[int] = 1800):
+        """
+        初始化 Redis 缓存实例
+
+        :param redis_url: Redis 服务的 URL
+        :param ttl: 缓存的存活时间，单位秒
+        """
+        self.redis_url = redis_url
+        self.ttl = ttl
+        try:
+            self.client = redis.Redis.from_url(
+                redis_url,
+                decode_responses=False,
+                socket_timeout=30,
+                socket_connect_timeout=5,
+                health_check_interval=60,
+            )
+            # 测试连接，确保 Redis 可用
+            self.client.ping()
+            logger.debug(f"Successfully connected to Redis")
+            self.set_memory_limit()
+        except Exception as e:
+            logger.error(f"Failed to connect to Redis: {e}")
+            raise RuntimeError("Redis connection failed") from e
+
+    def set_memory_limit(self, policy: Optional[str] = "allkeys-lru"):
+        """
+        动态设置 Redis 最大内存和内存淘汰策略
+        :param policy: 淘汰策略（如 'allkeys-lru'）
+        """
+        try:
+            # 如果有显式值，则直接使用，为 0 时说明不限制，如果未配置，开启 BIG_MEMORY_MODE 时为 "1024mb"，未开启时为 "256mb"
+            maxmemory = settings.CACHE_REDIS_MAXMEMORY or ("1024mb" if settings.BIG_MEMORY_MODE else "256mb")
+            self.client.config_set("maxmemory", maxmemory)
+            self.client.config_set("maxmemory-policy", policy)
+            logger.debug(f"Redis maxmemory set to {maxmemory}, policy: {policy}")
+        except Exception as e:
+            logger.error(f"Failed to set Redis maxmemory or policy: {e}")
+
+    @staticmethod
+    def is_container_type(t):
+        return t in (list, dict, tuple, set)
+
+    @classmethod
+    def serialize(cls, value: Any) -> bytes:
+        """
+        将值序列化为二进制数据，根据序列化方式标识格式
+        """
+        vt = type(value)
+        # 针对非容器类型使用缓存策略
+        if not cls.is_container_type(vt):
+            # 如果已知需要复杂序列化
+            if vt in cls._complex_serializable_types:
+                return b"PICKLE" + b"\x00" + pickle.dumps(value)
+            # 如果已知可以简单序列化
+            if vt in cls._simple_serializable_types:
+                json_data = json.dumps(value).encode("utf-8")
+                return b"JSON" + b"\x00" + json_data
+            # 对于未知的非容器类型，尝试简单序列化，如抛出异常，再使用复杂序列化
+            try:
+                json_data = json.dumps(value).encode("utf-8")
+                cls._simple_serializable_types.add(vt)
+                return b"JSON" + b"\x00" + json_data
+            except TypeError:
+                cls._complex_serializable_types.add(vt)
+                return b"PICKLE" + b"\x00" + pickle.dumps(value)
+        # 针对容器类型，每次尝试简单序列化，不使用缓存
+        else:
+            try:
+                json_data = json.dumps(value).encode("utf-8")
+                return b"JSON" + b"\x00" + json_data
+            except TypeError:
+                return b"PICKLE" + b"\x00" + pickle.dumps(value)
+
+    @classmethod
+    def deserialize(cls, value: bytes) -> Any:
+        """
+        将二进制数据反序列化为原始值，根据格式标识区分序列化方式
+        """
+        format_marker, data = value.split(b"\x00", 1)
+        if format_marker == b"JSON":
+            return json.loads(data.decode("utf-8"))
+        elif format_marker == b"PICKLE":
+            return pickle.loads(data)
+        else:
+            raise ValueError("Unknown serialization format")
+
+    # @staticmethod
+    # def serialize(value: Any) -> bytes:
+    #     return msgpack.packb(value, use_bin_type=True)
+    #
+    # @staticmethod
+    # def deserialize(value: bytes) -> Any:
+    #     return msgpack.unpackb(value, raw=False)
+
+    def get_redis_key(self, region: str, key: str) -> str:
+        """
+        获取缓存 Key
+        """
+        # 使用 region 作为缓存键的一部分
+        region = self.get_region(quote(region))
+        return f"{region}:key:{quote(key)}"
+
+    def set(self, key: str, value: Any, ttl: Optional[int] = None, 
+            region: Optional[str] = DEFAULT_CACHE_REGION, **kwargs) -> None:
+        """
+        设置缓存
+
+        :param key: 缓存的键
+        :param value: 缓存的值
+        :param ttl: 缓存的存活时间，单位秒如果未传入则使用默认值
+        :param region: 缓存的区
+        :param kwargs: kwargs
+        """
+        try:
+            ttl = ttl or self.ttl
+            redis_key = self.get_redis_key(region, key)
+            # 对值进行序列化
+            serialized_value = self.serialize(value)
+            kwargs.pop("maxsize", None)
+            self.client.set(redis_key, serialized_value, ex=ttl, **kwargs)
+        except Exception as e:
+            logger.error(f"Failed to set key: {key} in region: {region}, error: {e}")
+
+    def exists(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> bool:
+        """
+        判断缓存键是否存在
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 存在返回 True，否则返回 False
+        """
+        try:
+            redis_key = self.get_redis_key(region, key)
+            return self.client.exists(redis_key) == 1
+        except Exception as e:
+            logger.error(f"Failed to exists key: {key} region: {region}, error: {e}")
+            return False
+
+    def get(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> Optional[Any]:
+        """
+        获取缓存的值
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        :return: 返回缓存的值，如果缓存不存在返回 None
+        """
+        try:
+            redis_key = self.get_redis_key(region, key)
+            value = self.client.get(redis_key)
+            if value is not None:
+                return self.deserialize(value)  # noqa
+            return None
+        except Exception as e:
+            logger.error(f"Failed to get key: {key} in region: {region}, error: {e}")
+            return None
+
+    def delete(self, key: str, region: Optional[str] = DEFAULT_CACHE_REGION) -> None:
+        """
+        删除缓存
+
+        :param key: 缓存的键
+        :param region: 缓存的区
+        """
+        try:
+            redis_key = self.get_redis_key(region, key)
+            self.client.delete(redis_key)
+        except Exception as e:
+            logger.error(f"Failed to delete key: {key} in region: {region}, error: {e}")
+
+    def clear(self, region: Optional[str] = None) -> None:
+        """
+        清除指定区域的缓存或全部缓存
+
+        :param region: 缓存的区
+        """
+        try:
+            if region:
+                cache_region = self.get_region(quote(region))
+                redis_key = f"{cache_region}:key:*"
+                # self.client.delete(*self.client.keys(redis_key))
+                with self.client.pipeline() as pipe:
+                    for key in self.client.scan_iter(redis_key):
+                        pipe.delete(key)
+                    pipe.execute()
+                logger.info(f"Cleared Redis cache for region: {region}")
+            else:
+                self.client.flushdb()
+                logger.info("Cleared all Redis cache")
+        except Exception as e:
+            logger.error(f"Failed to clear cache, region: {region}, error: {e}")
+
+    def close(self) -> None:
+        """
+        关闭 Redis 客户端的连接池
+        """
+        if self.client:
+            self.client.close()
+
+
+def get_cache_backend(maxsize: Optional[int] = 512, ttl: Optional[int] = 1800) -> CacheBackend:
+    """
+    根据配置获取缓存后端实例
+
+    :param maxsize: 缓存的最大条目数
+    :param ttl: 缓存的默认存活时间，单位秒
+    :return: 返回缓存后端实例
+    """
+    cache_type = settings.CACHE_BACKEND_TYPE
+    logger.debug(f"Cache backend type from settings: {cache_type}")
+
+    if cache_type == "redis":
+        redis_url = settings.CACHE_BACKEND_URL
+        if redis_url:
+            try:
+                logger.debug(f"Attempting to use RedisBackend with URL: {redis_url}, TTL: {ttl}")
+                return RedisBackend(redis_url=redis_url, ttl=ttl)
+            except RuntimeError:
+                logger.warning("Falling back to CacheToolsBackend due to Redis connection failure.")
+        else:
+            logger.debug("Cache backend type is redis, but no valid REDIS_URL found. "
+                         "Falling back to CacheToolsBackend.")
+
+    # 如果不是 Redis，回退到内存缓存
+    logger.debug(f"Using CacheToolsBackend with default maxsize: {maxsize}, TTL: {ttl}")
+    return CacheToolsBackend(maxsize=maxsize, ttl=ttl)
+
+
+def cached(region: Optional[str] = None, maxsize: Optional[int] = 512, ttl: Optional[int] = 1800,
+           skip_none: Optional[bool] = True, skip_empty: Optional[bool] = False):
+    """
+    自定义缓存装饰器，支持为每个 key 动态传递 maxsize 和 ttl
+
+    :param region: 缓存的区
+    :param maxsize: 缓存的最大条目数，默认值为 512
+    :param ttl: 缓存的存活时间，单位秒，默认值为 1800
+    :param skip_none: 跳过 None 缓存，默认为 True
+    :param skip_empty: 跳过空值缓存（如 None, [], {}, "", set()），默认为 False
+    :return: 装饰器函数
+    """
+
+    def should_cache(value: Any) -> bool:
+        """
+        判断是否应该缓存结果，如果返回值是 None 或空值则不缓存
+
+        :param value: 要判断的缓存值
+        :return: 是否缓存结果
+        """
+        if skip_none and value is None:
+            return False
+        # if skip_empty and value in [None, [], {}, "", set()]:
+        if skip_empty and not value:
+            return False
+        return True
+
+    def is_valid_cache_value(cache_key: str, cached_value: Any, cache_region: str) -> bool:
+        """
+        判断指定的值是否为一个有效的缓存值
+
+        :param cache_key: 缓存的键
+        :param cached_value: 缓存的值
+        :param cache_region: 缓存的区
+        :return: 若值是有效的缓存值返回 True，否则返回 False
+        """
+        # 如果 skip_none 为 False，且 value 为 None，需要判断缓存实际是否存在
+        if not skip_none and cached_value is None:
+            if not cache_backend.exists(key=cache_key, region=cache_region):
+                return False
+        return True
+
+    def decorator(func):
+
+        # 获取缓存区
+        cache_region = region if region is not None else f"{func.__module__}.{func.__name__}"
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            # 获取缓存键
+            cache_key = cache_backend.get_cache_key(func, args, kwargs)
+            # 尝试获取缓存
+            cached_value = cache_backend.get(cache_key, region=cache_region)
+            if should_cache(cached_value) and is_valid_cache_value(cache_key, cached_value, cache_region):
+                return cached_value
+            # 执行函数并缓存结果
+            result = func(*args, **kwargs)
+            # 判断是否需要缓存
+            if not should_cache(result):
+                return result
+            # 设置缓存（如果有传入的 maxsize 和 ttl，则覆盖默认值）
+            cache_backend.set(cache_key, result, ttl=ttl, maxsize=maxsize, region=cache_region)
+            return result
+
+        def cache_clear():
+            """
+            清理缓存区
+            """
+            # 清理缓存区
+            cache_backend.clear(region=cache_region)
+
+        wrapper.cache_region = cache_region
+        wrapper.cache_clear = cache_clear
+        return wrapper
+
+    return decorator
+
+
+# 缓存后端实例
+cache_backend = get_cache_backend()
+
+
+def close_cache() -> None:
+    """
+    关闭缓存后端连接并清理资源
+    """
+    try:
+        if cache_backend:
+            cache_backend.close()
+            logger.info("Cache backend closed successfully.")
+    except Exception as e:
+        logger.info(f"Error while closing cache backend: {e}")

app/core/config.py

@@ -1,193 +1,236 @@
+import copy
+import json
+import os
 import secrets
+import sys
+import threading
 from pathlib import Path
-from typing import List
+from typing import Any, Dict, List, Optional, Tuple, Type
 
-from pydantic import BaseSettings
+from dotenv import set_key
+from pydantic import BaseModel, BaseSettings, validator, Field
+
+from app.log import logger, log_settings, LogConfigModel
+from app.utils.system import SystemUtils
+from app.utils.url import UrlUtils
 
 
-class Settings(BaseSettings):
+class SystemConfModel(BaseModel):
+    """
+    系统关键资源大小配置
+    """
+    # 缓存种子数量
+    torrents: int = 0
+    # 订阅刷新处理数量
+    refresh: int = 0
+    # TMDB请求缓存数量
+    tmdb: int = 0
+    # 豆瓣请求缓存数量
+    douban: int = 0
+    # Bangumi请求缓存数量
+    bangumi: int = 0
+    # Fanart请求缓存数量
+    fanart: int = 0
+    # 元数据缓存过期时间（秒）
+    meta: int = 0
+    # 调度器数量
+    scheduler: int = 0
+    # 线程池大小
+    threadpool: int = 0
+    # 数据库连接池大小
+    dbpool: int = 0
+    # 数据库连接池溢出数量
+    dbpooloverflow: int = 0
+
+
+class ConfigModel(BaseModel):
+    """
+    Pydantic 配置模型，描述所有配置项及其类型和默认值
+    """
+
+    class Config:
+        extra = "ignore"  # 忽略未定义的配置项
+
     # 项目名称
-    PROJECT_NAME = "MoviePilot"
+    PROJECT_NAME: str = "MoviePilot"
+    # 域名 格式；https://movie-pilot.org
+    APP_DOMAIN: str = ""
     # API路径
     API_V1_STR: str = "/api/v1"
+    # 前端资源路径
+    FRONTEND_PATH: str = "/public"
     # 密钥
     SECRET_KEY: str = secrets.token_urlsafe(32)
+    # RESOURCE密钥
+    RESOURCE_SECRET_KEY: str = secrets.token_urlsafe(32)
     # 允许的域名
-    ALLOWED_HOSTS: list = ["*"]
+    ALLOWED_HOSTS: list = Field(default_factory=lambda: ["*"])
     # TOKEN过期时间
     ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 8
+    # RESOURCE_TOKEN过期时间
+    RESOURCE_ACCESS_TOKEN_EXPIRE_SECONDS: int = 60 * 30
     # 时区
     TZ: str = "Asia/Shanghai"
     # API监听地址
     HOST: str = "0.0.0.0"
     # API监听端口
     PORT: int = 3001
+    # 前端监听端口
+    NGINX_PORT: int = 3000
     # 是否调试模式
     DEBUG: bool = False
     # 是否开发模式
     DEV: bool = False
+    # 是否在控制台输出 SQL 语句，默认关闭
+    DB_ECHO: bool = False
+    # 数据库连接池类型，QueuePool, NullPool
+    DB_POOL_TYPE: str = "QueuePool"
+    # 是否在获取连接时进行预先 ping 操作
+    DB_POOL_PRE_PING: bool = True
+    # 数据库连接的回收时间（秒）
+    DB_POOL_RECYCLE: int = 300
+    # 数据库连接池获取连接的超时时间（秒）
+    DB_POOL_TIMEOUT: int = 30
+    # SQLite 的 busy_timeout 参数，默认为 60 秒
+    DB_TIMEOUT: int = 60
+    # SQLite 是否启用 WAL 模式，默认开启
+    DB_WAL_ENABLE: bool = True
+    # 缓存类型，支持 cachetools 和 redis，默认使用 cachetools
+    CACHE_BACKEND_TYPE: str = "cachetools"
+    # 缓存连接字符串，仅外部缓存（如 Redis、Memcached）需要
+    CACHE_BACKEND_URL: Optional[str] = None
+    # Redis 缓存最大内存限制，未配置时，如开启大内存模式时为 "1024mb"，未开启时为 "256mb"
+    CACHE_REDIS_MAXMEMORY: Optional[str] = None
     # 配置文件目录
-    CONFIG_DIR: str = "/config"
+    CONFIG_DIR: Optional[str] = None
     # 超级管理员
     SUPERUSER: str = "admin"
-    # 超级管理员初始密码
-    SUPERUSER_PASSWORD: str = "password"
+    # 辅助认证，允许通过外部服务进行认证、单点登录以及自动创建用户
+    AUXILIARY_AUTH_ENABLE: bool = False
     # API密钥，需要更换
-    API_TOKEN: str = "moviepilot"
-    # 网络代理 IP:PORT
-    PROXY_HOST: str = None
-    # 媒体信息搜索来源
-    SEARCH_SOURCE: str = "themoviedb"
-    # 刮削入库的媒体文件
-    SCRAP_METADATA: bool = True
+    API_TOKEN: Optional[str] = None
+    # 网络代理服务器地址
+    PROXY_HOST: Optional[str] = None
+    # 登录页面电影海报,tmdb/bing/mediaserver
+    WALLPAPER: str = "tmdb"
+    # 自定义壁纸api地址
+    CUSTOMIZE_WALLPAPER_API_URL: Optional[str] = None
+    # 媒体搜索来源 themoviedb/douban/bangumi，多个用,分隔
+    SEARCH_SOURCE: str = "themoviedb,douban,bangumi"
+    # 媒体识别来源 themoviedb/douban
+    RECOGNIZE_SOURCE: str = "themoviedb"
+    # 刮削来源 themoviedb/douban
+    SCRAP_SOURCE: str = "themoviedb"
     # 新增已入库媒体是否跟随TMDB信息变化
     SCRAP_FOLLOW_TMDB: bool = True
-    # 刮削来源
-    SCRAP_SOURCE: str = "themoviedb"
     # TMDB图片地址
     TMDB_IMAGE_DOMAIN: str = "image.tmdb.org"
     # TMDB API地址
     TMDB_API_DOMAIN: str = "api.themoviedb.org"
+    # TMDB元数据语言
+    TMDB_LOCALE: str = "zh"
+    # 刮削使用TMDB原始语种图片
+    TMDB_SCRAP_ORIGINAL_IMAGE: bool = False
     # TMDB API Key
     TMDB_API_KEY: str = "db55323b8d3e4154498498a75642b381"
     # TVDB API Key
-    TVDB_API_KEY: str = "6b481081-10aa-440c-99f2-21d17717ee02"
+    TVDB_V4_API_KEY: str = "ed2aa66b-7899-4677-92a7-67bc9ce3d93a"
+    TVDB_V4_API_PIN: str = ""
+    # Fanart开关
+    FANART_ENABLE: bool = True
+    # Fanart语言
+    FANART_LANG: str = "zh,en"
     # Fanart API Key
     FANART_API_KEY: str = "d2d31f9ecabea050fc7d68aa3146015f"
+    # 115 AppId
+    U115_APP_ID: str = "100196807"
+    # Alipan AppId
+    ALIPAN_APP_ID: str = "ac1bf04dc9fd4d9aaabb65b4a668d403"
+    # 元数据识别缓存过期时间（小时）
+    META_CACHE_EXPIRE: int = 0
+    # 电视剧动漫的分类genre_ids
+    ANIME_GENREIDS: List[int] = Field(default=[16])
+    # 用户认证站点
+    AUTH_SITE: str = ""
+    # 重启自动升级
+    MOVIEPILOT_AUTO_UPDATE: str = 'release'
+    # 自动检查和更新站点资源包（站点索引、认证等）
+    AUTO_UPDATE_RESOURCE: bool = True
+    # 是否启用DOH解析域名
+    DOH_ENABLE: bool = False
+    # 使用 DOH 解析的域名列表
+    DOH_DOMAINS: str = ("api.themoviedb.org,"
+                        "api.tmdb.org,"
+                        "webservice.fanart.tv,"
+                        "api.github.com,"
+                        "github.com,"
+                        "raw.githubusercontent.com,"
+                        "codeload.github.com,"
+                        "api.telegram.org")
+    # DOH 解析服务器列表
+    DOH_RESOLVERS: str = "1.0.0.1,1.1.1.1,9.9.9.9,149.112.112.112"
     # 支持的后缀格式
-    RMT_MEDIAEXT: list = ['.mp4', '.mkv', '.ts', '.iso',
-                          '.rmvb', '.avi', '.mov', '.mpeg',
-                          '.mpg', '.wmv', '.3gp', '.asf',
-                          '.m4v', '.flv', '.m2ts', '.strm',
-                          '.tp']
+    RMT_MEDIAEXT: list = Field(
+        default_factory=lambda: ['.mp4', '.mkv', '.ts', '.iso',
+                                 '.rmvb', '.avi', '.mov', '.mpeg',
+                                 '.mpg', '.wmv', '.3gp', '.asf',
+                                 '.m4v', '.flv', '.m2ts', '.strm',
+                                 '.tp', '.f4v']
+    )
     # 支持的字幕文件后缀格式
-    RMT_SUBEXT: list = ['.srt', '.ass', '.ssa']
+    RMT_SUBEXT: list = Field(default_factory=lambda: ['.srt', '.ass', '.ssa', '.sup'])
     # 支持的音轨文件后缀格式
-    RMT_AUDIO_TRACK_EXT: list = ['.mka']
-    # 索引器
-    INDEXER: str = "builtin"
+    RMT_AUDIO_TRACK_EXT: list = Field(default_factory=lambda: ['.mka'])
+    # 音轨文件后缀格式
+    RMT_AUDIOEXT: list = Field(
+        default_factory=lambda: ['.aac', '.ac3', '.amr', '.caf', '.cda', '.dsf',
+                                 '.dff', '.kar', '.m4a', '.mp1', '.mp2', '.mp3',
+                                 '.mid', '.mod', '.mka', '.mpc', '.nsf', '.ogg',
+                                 '.pcm', '.rmi', '.s3m', '.snd', '.spx', '.tak',
+                                 '.tta', '.vqf', '.wav', '.wma',
+                                 '.aifc', '.aiff', '.alac', '.adif', '.adts',
+                                 '.flac', '.midi', '.opus', '.sfalc']
+    )
+    # 下载器临时文件后缀
+    DOWNLOAD_TMPEXT: list = Field(default_factory=lambda: ['.!qb', '.part'])
+    # 媒体服务器同步间隔（小时）
+    MEDIASERVER_SYNC_INTERVAL: int = 6
     # 订阅模式
     SUBSCRIBE_MODE: str = "spider"
     # RSS订阅模式刷新时间间隔（分钟）
     SUBSCRIBE_RSS_INTERVAL: int = 30
+    # 订阅数据共享
+    SUBSCRIBE_STATISTIC_SHARE: bool = True
     # 订阅搜索开关
     SUBSCRIBE_SEARCH: bool = False
-    # 用户认证站点
-    AUTH_SITE: str = ""
-    # 交互搜索自动下载用户ID，使用,分割
-    AUTO_DOWNLOAD_USER: str = None
-    # 消息通知渠道 telegram/wechat/slack，多个通知渠道用,分隔
-    MESSAGER: str = "telegram"
-    # WeChat企业ID
-    WECHAT_CORPID: str = None
-    # WeChat应用Secret
-    WECHAT_APP_SECRET: str = None
-    # WeChat应用ID
-    WECHAT_APP_ID: str = None
-    # WeChat代理服务器
-    WECHAT_PROXY: str = "https://qyapi.weixin.qq.com"
-    # WeChat Token
-    WECHAT_TOKEN: str = None
-    # WeChat EncodingAESKey
-    WECHAT_ENCODING_AESKEY: str = None
-    # WeChat 管理员
-    WECHAT_ADMINS: str = None
-    # Telegram Bot Token
-    TELEGRAM_TOKEN: str = None
-    # Telegram Chat ID
-    TELEGRAM_CHAT_ID: str = None
-    # Telegram 用户ID，使用,分隔
-    TELEGRAM_USERS: str = ""
-    # Telegram 管理员ID，使用,分隔
-    TELEGRAM_ADMINS: str = ""
-    # Slack Bot User OAuth Token
-    SLACK_OAUTH_TOKEN: str = ""
-    # Slack App-Level Token
-    SLACK_APP_TOKEN: str = ""
-    # Slack 频道名称
-    SLACK_CHANNEL: str = ""
-    # SynologyChat Webhook
-    SYNOLOGYCHAT_WEBHOOK: str = ""
-    # SynologyChat Token
-    SYNOLOGYCHAT_TOKEN: str = ""
-    # 下载器 qbittorrent/transmission
-    DOWNLOADER: str = "qbittorrent"
-    # 下载器监控开关
-    DOWNLOADER_MONITOR: bool = True
-    # Qbittorrent地址，IP:PORT
-    QB_HOST: str = None
-    # Qbittorrent用户名
-    QB_USER: str = None
-    # Qbittorrent密码
-    QB_PASSWORD: str = None
-    # Qbittorrent分类自动管理
-    QB_CATEGORY: bool = False
-    # Transmission地址，IP:PORT
-    TR_HOST: str = None
-    # Transmission用户名
-    TR_USER: str = None
-    # Transmission密码
-    TR_PASSWORD: str = None
+    # 检查本地媒体库是否存在资源开关
+    LOCAL_EXISTS_SEARCH: bool = False
+    # 搜索多个名称
+    SEARCH_MULTIPLE_NAME: bool = False
+    # 站点数据刷新间隔（小时）
+    SITEDATA_REFRESH_INTERVAL: int = 6
+    # 读取和发送站点消息
+    SITE_MESSAGE: bool = True
     # 种子标签
     TORRENT_TAG: str = "MOVIEPILOT"
-    # 下载保存目录，容器内映射路径需要一致
-    DOWNLOAD_PATH: str = "/downloads"
-    # 电影下载保存目录，容器内映射路径需要一致
-    DOWNLOAD_MOVIE_PATH: str = None
-    # 电视剧下载保存目录，容器内映射路径需要一致
-    DOWNLOAD_TV_PATH: str = None
-    # 动漫下载保存目录，容器内映射路径需要一致
-    DOWNLOAD_ANIME_PATH: str = None
-    # 下载目录二级分类
-    DOWNLOAD_CATEGORY: bool = False
     # 下载站点字幕
     DOWNLOAD_SUBTITLE: bool = True
-    # 媒体服务器 emby/jellyfin/plex，多个媒体服务器,分割
-    MEDIASERVER: str = "emby"
-    # 入库刷新媒体库
-    REFRESH_MEDIASERVER: bool = True
-    # 媒体服务器同步间隔（小时）
-    MEDIASERVER_SYNC_INTERVAL: int = 6
-    # 媒体服务器同步黑名单，多个媒体库名称,分割
-    MEDIASERVER_SYNC_BLACKLIST: str = None
-    # EMBY服务器地址，IP:PORT
-    EMBY_HOST: str = None
-    # EMBY Api Key
-    EMBY_API_KEY: str = None
-    # Jellyfin服务器地址，IP:PORT
-    JELLYFIN_HOST: str = None
-    # Jellyfin Api Key
-    JELLYFIN_API_KEY: str = None
-    # Plex服务器地址，IP:PORT
-    PLEX_HOST: str = None
-    # Plex Token
-    PLEX_TOKEN: str = None
-    # 转移方式 link/copy/move/softlink
-    TRANSFER_TYPE: str = "copy"
+    # 交互搜索自动下载用户ID，使用,分割
+    AUTO_DOWNLOAD_USER: Optional[str] = None
+    # CookieCloud是否启动本地服务
+    COOKIECLOUD_ENABLE_LOCAL: Optional[bool] = False
     # CookieCloud服务器地址
     COOKIECLOUD_HOST: str = "https://movie-pilot.org/cookiecloud"
     # CookieCloud用户KEY
-    COOKIECLOUD_KEY: str = None
+    COOKIECLOUD_KEY: Optional[str] = None
     # CookieCloud端对端加密密码
-    COOKIECLOUD_PASSWORD: str = None
+    COOKIECLOUD_PASSWORD: Optional[str] = None
     # CookieCloud同步间隔（分钟）
-    COOKIECLOUD_INTERVAL: int = 60 * 24
-    # OCR服务器地址
-    OCR_HOST: str = "https://movie-pilot.org"
+    COOKIECLOUD_INTERVAL: Optional[int] = 60 * 24
+    # CookieCloud同步黑名单，多个域名,分割
+    COOKIECLOUD_BLACKLIST: Optional[str] = None
     # CookieCloud对应的浏览器UA
-    USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36 Edg/113.0.1774.57"
-    # 媒体库目录，多个目录使用,分隔
-    LIBRARY_PATH: str = None
-    # 电影媒体库目录名，默认"电影"
-    LIBRARY_MOVIE_NAME: str = None
-    # 电视剧媒体库目录名，默认"电视剧"
-    LIBRARY_TV_NAME: str = None
-    # 动漫媒体库目录名，默认"电视剧/动漫"
-    LIBRARY_ANIME_NAME: str = None
-    # 二级分类
-    LIBRARY_CATEGORY: bool = True
-    # 电视剧动漫的分类genre_ids
-    ANIME_GENREIDS = [16]
+    USER_AGENT: str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/113.0.0.0 Safari/537.36 Edg/113.0.1774.57"
     # 电影重命名格式
     MOVIE_RENAME_FORMAT: str = "{{title}}{% if year %} ({{year}}){% endif %}" \
                                "/{{title}}{% if year %} ({{year}}){% endif %}{% if part %}-{{part}}{% endif %}{% if videoFormat %} - {{videoFormat}}{% endif %}" \
@@ -197,8 +240,275 @@ class Settings(BaseSettings):
                             "/Season {{season}}" \
                             "/{{title}} - {{season_episode}}{% if part %}-{{part}}{% endif %}{% if episode %} - 第 {{episode}} 集{% endif %}" \
                             "{{fileExt}}"
+    # OCR服务器地址
+    OCR_HOST: str = "https://movie-pilot.org"
+    # 服务器地址，对应 https://github.com/jxxghp/MoviePilot-Server 项目
+    MP_SERVER_HOST: str = "https://movie-pilot.org"
+    # 插件市场仓库地址，多个地址使用,分隔，地址以/结尾
+    PLUGIN_MARKET: str = ("https://github.com/jxxghp/MoviePilot-Plugins,"
+                          "https://github.com/thsrite/MoviePilot-Plugins,"
+                          "https://github.com/honue/MoviePilot-Plugins,"
+                          "https://github.com/InfinityPacer/MoviePilot-Plugins,"
+                          "https://github.com/DDS-Derek/MoviePilot-Plugins,"
+                          "https://github.com/madrays/MoviePilot-Plugins,"
+                          "https://github.com/justzerock/MoviePilot-Plugins,"
+                          "https://github.com/KoWming/MoviePilot-Plugins,"
+                          "https://github.com/wikrin/MoviePilot-Plugins,"
+                          "https://github.com/HankunYu/MoviePilot-Plugins,"
+                          "https://github.com/baozaodetudou/MoviePilot-Plugins,"
+                          "https://github.com/Aqr-K/MoviePilot-Plugins,"
+                          "https://github.com/hotlcc/MoviePilot-Plugins-Third,"
+                          "https://github.com/gxterry/MoviePilot-Plugins,"
+                          "https://github.com/DzAvril/MoviePilot-Plugins")
+    # 插件安装数据共享
+    PLUGIN_STATISTIC_SHARE: bool = True
+    # 是否开启插件热加载
+    PLUGIN_AUTO_RELOAD: bool = False
+    # Github token，提高请求api限流阈值 ghp_****
+    GITHUB_TOKEN: Optional[str] = None
+    # Github代理服务器，格式：https://mirror.ghproxy.com/
+    GITHUB_PROXY: Optional[str] = ''
+    # pip镜像站点，格式：https://mirrors.tuna.tsinghua.edu.cn/pypi/web/simple
+    PIP_PROXY: Optional[str] = ''
+    # 指定的仓库Github token，多个仓库使用,分隔，格式：{user1}/{repo1}:ghp_****,{user2}/{repo2}:github_pat_****
+    REPO_GITHUB_TOKEN: Optional[str] = None
     # 大内存模式
     BIG_MEMORY_MODE: bool = False
+    # 是否启用内存监控
+    MEMORY_ANALYSIS: bool = False
+    # 内存快照间隔（分钟）
+    MEMORY_SNAPSHOT_INTERVAL: int = 30
+    # 保留的内存快照文件数量
+    MEMORY_SNAPSHOT_KEEP_COUNT: int = 20
+    # 全局图片缓存，将媒体图片缓存到本地
+    GLOBAL_IMAGE_CACHE: bool = False
+    # 是否启用编码探测的性能模式
+    ENCODING_DETECTION_PERFORMANCE_MODE: bool = True
+    # 编码探测的最低置信度阈值
+    ENCODING_DETECTION_MIN_CONFIDENCE: float = 0.8
+    # 允许的图片缓存域名
+    SECURITY_IMAGE_DOMAINS: list = Field(default=[
+        "image.tmdb.org",
+        "static-mdb.v.geilijiasu.com",
+        "bing.com",
+        "doubanio.com",
+        "lain.bgm.tv",
+        "raw.githubusercontent.com",
+        "github.com",
+        "thetvdb.com",
+        "cctvpic.com",
+        "iqiyipic.com",
+        "hdslb.com",
+        "cmvideo.cn",
+        "ykimg.com",
+        "qpic.cn"
+    ])
+    # 允许的图片文件后缀格式
+    SECURITY_IMAGE_SUFFIXES: list = Field(default=[".jpg", ".jpeg", ".png", ".webp", ".gif", ".svg", ".avif"])
+    # 重命名时支持的S0别名
+    RENAME_FORMAT_S0_NAMES: list = Field(default=["Specials", "SPs"])
+    # 为指定默认字幕添加.default后缀
+    DEFAULT_SUB: Optional[str] = "zh-cn"
+    # Docker Client API地址
+    DOCKER_CLIENT_API: Optional[str] = "tcp://127.0.0.1:38379"
+
+
+class Settings(BaseSettings, ConfigModel, LogConfigModel):
+    """
+    系统配置类
+    """
+
+    class Config:
+        case_sensitive = True
+        env_file = SystemUtils.get_env_path()
+        env_file_encoding = "utf-8"
+
+    def __init__(self, **kwargs):
+        super().__init__(**kwargs)
+        # 初始化配置目录及子目录
+        for path in [self.CONFIG_PATH, self.TEMP_PATH, self.LOG_PATH, self.COOKIE_PATH]:
+            if not path.exists():
+                path.mkdir(parents=True, exist_ok=True)
+        # 如果是二进制程序，确保配置文件存在
+        if SystemUtils.is_frozen():
+            app_env_path = self.CONFIG_PATH / "app.env"
+            if not app_env_path.exists():
+                SystemUtils.copy(self.INNER_CONFIG_PATH / "app.env", app_env_path)
+
+    @staticmethod
+    def validate_api_token(value: Any, original_value: Any) -> Tuple[Any, bool]:
+        """
+        校验 API_TOKEN
+        """
+        if isinstance(value, (list, dict, set)):
+            value = copy.deepcopy(value)
+        value = value.strip() if isinstance(value, str) else None
+        if not value or len(value) < 16:
+            new_token = secrets.token_urlsafe(16)
+            if not value:
+                logger.info(f"'API_TOKEN' 未设置，已随机生成新的【API_TOKEN】{new_token}")
+            else:
+                logger.warning(f"'API_TOKEN' 长度不足 16 个字符，存在安全隐患，已随机生成新的【API_TOKEN】{new_token}")
+            return new_token, True
+        return value, str(value) != str(original_value)
+
+    @staticmethod
+    def generic_type_converter(value: Any, original_value: Any, expected_type: Type, default: Any, field_name: str,
+                               raise_exception: bool = False) -> Tuple[Any, bool]:
+        """
+        通用类型转换函数，根据预期类型转换值。如果转换失败，返回默认值
+        :return: 元组 (转换后的值, 是否需要更新)
+        """
+        if isinstance(value, (list, dict, set)):
+            value = copy.deepcopy(value)
+        # 如果 value 是 None，仍需要检查与 original_value 是否不一致
+        if value is None:
+            return default, str(value) != str(original_value)
+
+        if isinstance(value, str):
+            value = value.strip()
+
+        try:
+            if expected_type is bool:
+                if isinstance(value, bool):
+                    return value, str(value).lower() != str(original_value).lower()
+                if isinstance(value, str):
+                    value_clean = value.lower()
+                    bool_map = {
+                        "false": False, "no": False, "0": False, "off": False,
+                        "true": True, "yes": True, "1": True, "on": True
+                    }
+                    if value_clean in bool_map:
+                        converted = bool_map[value_clean]
+                        return converted, str(converted).lower() != str(original_value).lower()
+                elif isinstance(value, (int, float)):
+                    converted = bool(value)
+                    return converted, str(converted).lower() != str(original_value).lower()
+                return default, True
+            elif expected_type is int:
+                if isinstance(value, int):
+                    return value, str(value) != str(original_value)
+                if isinstance(value, str):
+                    converted = int(value)
+                    return converted, str(converted) != str(original_value)
+            elif expected_type is float:
+                if isinstance(value, float):
+                    return value, str(value) != str(original_value)
+                if isinstance(value, str):
+                    converted = float(value)
+                    return converted, str(converted) != str(original_value)
+            elif expected_type is str:
+                converted = str(value).strip()
+                return converted, converted != str(original_value)
+            elif expected_type is list:
+                if isinstance(value, list):
+                    return value, str(value) != str(original_value)
+                if isinstance(value, str):
+                    items = json.loads(value)
+                    if isinstance(original_value, list):
+                        return items, items != original_value
+                    else:
+                        return items, str(items) != str(original_value)
+            else:
+                return value, str(value) != str(original_value)
+        except (ValueError, TypeError) as e:
+            if raise_exception:
+                raise ValueError(f"配置项 '{field_name}' 的值 '{value}' 无法转换成正确的类型") from e
+            logger.error(
+                f"配置项 '{field_name}' 的值 '{value}' 无法转换成正确的类型，使用默认值 '{default}'，错误信息: {e}")
+        return default, True
+
+    @validator('*', pre=True, always=True)
+    def generic_type_validator(cls, value: Any, field):  # noqa
+        """
+        通用校验器，尝试将配置值转换为期望的类型
+        """
+        if field.name == "API_TOKEN":
+            converted_value, needs_update = cls.validate_api_token(value, value)
+        else:
+            converted_value, needs_update = cls.generic_type_converter(value, value, field.type_, field.default,
+                                                                       field.name)
+        if needs_update:
+            cls.update_env_config(field, value, converted_value)
+        return converted_value
+
+    @staticmethod
+    def update_env_config(field: Any, original_value: Any, converted_value: Any) -> Tuple[bool, str]:
+        """
+        更新 env 配置
+        """
+        message = None
+        is_converted = original_value is not None and str(original_value) != str(converted_value)
+        if is_converted:
+            message = f"配置项 '{field.name}' 的值 '{original_value}' 无效，已替换为 '{converted_value}'"
+            logger.warning(message)
+
+        if field.name in os.environ:
+            message = f"配置项 '{field.name}' 已在环境变量中设置，请手动更新以保持一致性"
+            logger.warning(message)
+            return False, message
+        else:
+            # 如果是列表、字典或集合类型，将其转换为JSON字符串
+            if isinstance(converted_value, (list, dict, set)):
+                value_to_write = json.dumps(converted_value)
+            else:
+                value_to_write = str(converted_value) if converted_value is not None else ""
+
+            set_key(dotenv_path=SystemUtils.get_env_path(), key_to_set=field.name, value_to_set=value_to_write,
+                    quote_mode="always")
+            if is_converted:
+                logger.info(f"配置项 '{field.name}' 已自动修正并写入到 'app.env' 文件")
+        return True, message
+
+    def update_setting(self, key: str, value: Any) -> Tuple[Optional[bool], str]:
+        """
+        更新单个配置项
+        :param key: 配置项的名称
+        :param value: 配置项的新值
+        :return: (是否成功 True 成功/False 失败/None 无需更新, 错误信息)
+        """
+        if not hasattr(self, key):
+            return False, f"配置项 '{key}' 不存在"
+
+        try:
+            field = self.__fields__[key]
+            original_value = getattr(self, key)
+            if field.name == "API_TOKEN":
+                converted_value, needs_update = self.validate_api_token(value, original_value)
+            else:
+                converted_value, needs_update = self.generic_type_converter(value,
+                                                                            original_value,
+                                                                            field.type_,
+                                                                            field.default,
+                                                                            key)
+            # 如果没有抛出异常，则统一使用 converted_value 进行更新
+            if needs_update or str(value) != str(converted_value):
+                success, message = self.update_env_config(field, value, converted_value)
+                # 仅成功更新配置时，才更新内存
+                if success:
+                    setattr(self, key, converted_value)
+                    if hasattr(log_settings, key):
+                        setattr(log_settings, key, converted_value)
+                return success, message
+            return None, ""
+        except Exception as e:
+            return False, str(e)
+
+    def update_settings(self, env: Dict[str, Any]) -> Dict[str, Tuple[Optional[bool], str]]:
+        """
+        更新多个配置项
+        """
+        results = {}
+        for k, v in env.items():
+            results[k] = self.update_setting(k, v)
+        return results
+
+    @property
+    def VERSION_FLAG(self) -> str:
+        """
+        版本标识，用来区分重大版本，为空则为v1，不允许外部修改
+        """
+        return "v2"
 
     @property
     def INNER_CONFIG_PATH(self):
@@ -208,12 +518,20 @@ class Settings(BaseSettings):
     def CONFIG_PATH(self):
         if self.CONFIG_DIR:
             return Path(self.CONFIG_DIR)
-        return self.INNER_CONFIG_PATH
+        elif SystemUtils.is_docker():
+            return Path("/config")
+        elif SystemUtils.is_frozen():
+            return Path(sys.executable).parent / "config"
+        return self.ROOT_PATH / "config"
 
     @property
     def TEMP_PATH(self):
         return self.CONFIG_PATH / "temp"
 
+    @property
+    def CACHE_PATH(self):
+        return self.CONFIG_PATH / "cache"
+
     @property
     def ROOT_PATH(self):
         return Path(__file__).parents[2]
@@ -227,24 +545,41 @@ class Settings(BaseSettings):
         return self.CONFIG_PATH / "logs"
 
     @property
-    def CACHE_CONF(self):
+    def COOKIE_PATH(self):
+        return self.CONFIG_PATH / "cookies"
+
+    @property
+    def CONF(self) -> SystemConfModel:
+        """
+        根据内存模式返回系统配置
+        """
         if self.BIG_MEMORY_MODE:
-            return {
-                "tmdb": 1024,
-                "refresh": 50,
-                "torrents": 100,
-                "douban": 512,
-                "fanart": 512,
-                "meta": 15 * 24 * 3600
-            }
-        return {
-            "tmdb": 256,
-            "refresh": 30,
-            "torrents": 50,
-            "douban": 256,
-            "fanart": 128,
-            "meta": 7 * 24 * 3600
-        }
+            return SystemConfModel(
+                torrents=200,
+                refresh=100,
+                tmdb=1024,
+                douban=512,
+                bangumi=512,
+                fanart=512,
+                meta=(self.META_CACHE_EXPIRE or 24) * 3600,
+                scheduler=100,
+                threadpool=100,
+                dbpool=100,
+                dbpooloverflow=50
+            )
+        return SystemConfModel(
+            torrents=100,
+            refresh=50,
+            tmdb=256,
+            douban=256,
+            bangumi=256,
+            fanart=128,
+            meta=(self.META_CACHE_EXPIRE or 2) * 3600,
+            scheduler=50,
+            threadpool=50,
+            dbpool=50,
+            dbpooloverflow=20
+        )
 
     @property
     def PROXY(self):
@@ -261,30 +596,126 @@ class Settings(BaseSettings):
             return {
                 "server": self.PROXY_HOST
             }
+        return None
 
     @property
-    def LIBRARY_PATHS(self) -> List[Path]:
-        if self.LIBRARY_PATH:
-            return [Path(path) for path in self.LIBRARY_PATH.split(",")]
-        return []
+    def GITHUB_HEADERS(self):
+        """
+        Github请求头
+        """
+        if self.GITHUB_TOKEN:
+            return {
+                "Authorization": f"Bearer {self.GITHUB_TOKEN}",
+                "User-Agent": self.USER_AGENT,
+            }
+        return {}
 
-    def __init__(self, **kwargs):
-        super().__init__(**kwargs)
-        with self.CONFIG_PATH as p:
-            if not p.exists():
-                p.mkdir(parents=True, exist_ok=True)
-        with self.TEMP_PATH as p:
-            if not p.exists():
-                p.mkdir(parents=True, exist_ok=True)
-        with self.LOG_PATH as p:
-            if not p.exists():
-                p.mkdir(parents=True, exist_ok=True)
+    def REPO_GITHUB_HEADERS(self, repo: str = None):
+        """
+        Github指定的仓库请求头
+        :param repo: 指定的仓库名称，格式为 "user/repo"。如果为空，或者没有找到指定仓库请求头，则返回默认的请求头信息
+        :return: Github请求头
+        """
+        # 如果没有传入指定的仓库名称，或没有配置指定的仓库Token，则返回默认的请求头信息
+        if not repo or not self.REPO_GITHUB_TOKEN:
+            return self.GITHUB_HEADERS
+        headers = {}
+        # 格式：{user1}/{repo1}:ghp_****,{user2}/{repo2}:github_pat_****
+        token_pairs = self.REPO_GITHUB_TOKEN.split(",")
+        for token_pair in token_pairs:
+            try:
+                parts = token_pair.split(":")
+                if len(parts) != 2:
+                    print(f"无效的令牌格式: {token_pair}")
+                    continue
+                repo_info = parts[0].strip()
+                token = parts[1].strip()
+                if not repo_info or not token:
+                    print(f"无效的令牌或仓库信息: {token_pair}")
+                    continue
+                headers[repo_info] = {
+                    "Authorization": f"Bearer {token}",
+                    "User-Agent": self.USER_AGENT,
+                }
+            except Exception as e:
+                print(f"处理令牌对 '{token_pair}' 时出错: {e}")
+        # 如果传入了指定的仓库名称，则返回该仓库的请求头信息，否则返回默认请求头
+        return headers.get(repo, self.GITHUB_HEADERS)
 
-    class Config:
-        case_sensitive = True
+    @property
+    def VAPID(self):
+        return {
+            "subject": f"mailto:{self.SUPERUSER}@movie-pilot.org",
+            "publicKey": "BH3w49sZA6jXUnE-yt4jO6VKh73lsdsvwoJ6Hx7fmPIDKoqGiUl2GEoZzy-iJfn4SfQQcx7yQdHf9RknwrL_lSM",
+            "privateKey": "JTixnYY0vEw97t9uukfO3UWKfHKJdT5kCQDiv3gu894"
+        }
+
+    def MP_DOMAIN(self, url: str = None):
+        if not self.APP_DOMAIN:
+            return None
+        return UrlUtils.combine_url(host=self.APP_DOMAIN, path=url)
 
 
-settings = Settings(
-    _env_file=Settings().CONFIG_PATH / "app.env",
-    _env_file_encoding="utf-8"
-)
+# 实例化配置
+settings = Settings()
+
+
+class GlobalVar(object):
+    """
+    全局标识
+    """
+    # 系统停止事件
+    STOP_EVENT: threading.Event = threading.Event()
+    # webpush订阅
+    SUBSCRIPTIONS: List[dict] = []
+    # 需应急停止的工作流
+    EMERGENCY_STOP_WORKFLOWS: List[int] = []
+
+    def stop_system(self):
+        """
+        停止系统
+        """
+        self.STOP_EVENT.set()
+
+    @property
+    def is_system_stopped(self):
+        """
+        是否停止
+        """
+        return self.STOP_EVENT.is_set()
+
+    def get_subscriptions(self):
+        """
+        获取webpush订阅
+        """
+        return self.SUBSCRIPTIONS
+
+    def push_subscription(self, subscription: dict):
+        """
+        添加webpush订阅
+        """
+        self.SUBSCRIPTIONS.append(subscription)
+
+    def stop_workflow(self, workflow_id: int):
+        """
+        停止工作流
+        """
+        if workflow_id not in self.EMERGENCY_STOP_WORKFLOWS:
+            self.EMERGENCY_STOP_WORKFLOWS.append(workflow_id)
+
+    def workflow_resume(self, workflow_id: int):
+        """
+        恢复工作流
+        """
+        if workflow_id in self.EMERGENCY_STOP_WORKFLOWS:
+            self.EMERGENCY_STOP_WORKFLOWS.remove(workflow_id)
+
+    def is_workflow_stopped(self, workflow_id: int):
+        """
+        是否停止工作流
+        """
+        return self.is_system_stopped or workflow_id in self.EMERGENCY_STOP_WORKFLOWS
+
+
+# 全局标识
+global_vars = GlobalVar()

app/core/context.py

@@ -1,11 +1,13 @@
 import re
-from dataclasses import dataclass, field, asdict
-from typing import List, Dict, Any, Tuple
+from dataclasses import dataclass, field
+from datetime import datetime
+from typing import List, Dict, Any, Tuple, Optional
 
 from app.core.config import settings
 from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfo
 from app.schemas.types import MediaType
+from app.utils.string import StringUtils
 
 
 @dataclass
@@ -22,6 +24,8 @@ class TorrentInfo:
     site_proxy: bool = False
     # 站点优先级
     site_order: int = 0
+    # 站点下载器
+    site_downloader: str = None
     # 种子名称
     title: str = None
     # 种子副标题
@@ -33,7 +37,7 @@ class TorrentInfo:
     # 详情页面
     page_url: str = None
     # 种子大小
-    size: float = 0
+    size: float = 0.0
     # 做种者
     seeders: int = 0
     # 下载者
@@ -44,6 +48,8 @@ class TorrentInfo:
     pubdate: str = None
     # 已过时间
     date_elapsed: str = None
+    # 免费截止时间
+    freedate: str = None
     # 上传因子
     uploadvolumefactor: float = None
     # 下载因子
@@ -54,6 +60,8 @@ class TorrentInfo:
     labels: list = field(default_factory=list)
     # 种子优先级
     pri_order: int = 0
+    # 种子分类 电影/电视剧
+    category: str = None
 
     def __setattr__(self, name: str, value: Any):
         self.__dict__[name] = value
@@ -90,7 +98,9 @@ class TorrentInfo:
             "1.0 1.0": "普通",
             "1.0 0.0": "免费",
             "2.0 1.0": "2X",
+            "4.0 1.0": "4X",
             "2.0 0.0": "2X免费",
+            "4.0 0.0": "4X免费",
             "1.0 0.5": "50%",
             "2.0 0.5": "2X 50%",
             "1.0 0.7": "70%",
@@ -105,21 +115,55 @@ class TorrentInfo:
         """
         return self.get_free_string(self.uploadvolumefactor, self.downloadvolumefactor)
 
+    @property
+    def freedate_diff(self):
+        """
+        返回免费剩余时间
+        """
+        if not self.freedate:
+            return ""
+        return StringUtils.diff_time_str(self.freedate)
+
+    def pub_minutes(self) -> float:
+        """
+        返回发布时间距离当前时间的分钟数
+        """
+        if not self.pubdate:
+            return 0
+        try:
+            pub_date = datetime.strptime(self.pubdate, "%Y-%m-%d %H:%M:%S")
+            now_datetime = datetime.now()
+            return (now_datetime - pub_date).total_seconds() // 60
+        except Exception as e:
+            print(f"种子发布时间获取失败: {e}")
+            return 0
+
     def to_dict(self):
         """
         返回字典
         """
-        dicts = asdict(self)
+        dicts = vars(self).copy()
         dicts["volume_factor"] = self.volume_factor
+        dicts["freedate_diff"] = self.freedate_diff
         return dicts
 
 
 @dataclass
 class MediaInfo:
+    # 来源：themoviedb、douban、bangumi
+    source: str = None
     # 类型 电影、电视剧
     type: MediaType = None
     # 媒体标题
     title: str = None
+    # 英文标题
+    en_title: str = None
+    # 香港标题
+    hk_title: str = None
+    # 台湾标题
+    tw_title: str = None
+    # 新加坡标题
+    sg_title: str = None
     # 年份
     year: str = None
     # 季
@@ -132,6 +176,10 @@ class MediaInfo:
     tvdb_id: int = None
     # 豆瓣ID
     douban_id: str = None
+    # Bangumi ID
+    bangumi_id: int = None
+    # 合集ID
+    collection_id: int = None
     # 媒体原语种
     original_language: str = None
     # 媒体原发行标题
@@ -145,7 +193,7 @@ class MediaInfo:
     # LOGO
     logo_path: str = None
     # 评分
-    vote_average: int = 0
+    vote_average: float = 0.0
     # 描述
     overview: str = None
     # 风格ID
@@ -164,6 +212,8 @@ class MediaInfo:
     tmdb_info: dict = field(default_factory=dict)
     # 豆瓣 INFO
     douban_info: dict = field(default_factory=dict)
+    # Bangumi INFO
+    bangumi_info: dict = field(default_factory=dict)
     # 导演
     directors: List[dict] = field(default_factory=list)
     # 演员
@@ -212,6 +262,12 @@ class MediaInfo:
     runtime: int = None
     # 下一集
     next_episode_to_air: dict = field(default_factory=dict)
+    # 内容分级
+    content_rating: str = None
+    # 全部剧集组
+    episode_groups: List[dict] = field(default_factory=list)
+    # 剧集组
+    episode_group: str = None
 
     def __post_init__(self):
         # 设置媒体信息
@@ -219,6 +275,8 @@ class MediaInfo:
             self.set_tmdb_info(self.tmdb_info)
         if self.douban_info:
             self.set_douban_info(self.douban_info)
+        if self.bangumi_info:
+            self.set_bangumi_info(self.bangumi_info)
 
     def __setattr__(self, name: str, value: Any):
         self.__dict__[name] = value
@@ -318,16 +376,18 @@ class MediaInfo:
                 return [], []
             directors = []
             actors = []
-            for cast in _credits.get("cast"):
+            for cast in _credits.get("cast") or []:
                 if cast.get("known_for_department") == "Acting":
                     actors.append(cast)
-            for crew in _credits.get("crew"):
+            for crew in _credits.get("crew") or []:
                 if crew.get("job") in ["Director", "Writer", "Editor", "Producer"]:
                     directors.append(crew)
             return directors, actors
 
         if not info:
             return
+        # 来源
+        self.source = "themoviedb"
         # 本体
         self.tmdb_info = info
         # 类型
@@ -345,6 +405,8 @@ class MediaInfo:
         if info.get("external_ids"):
             self.tvdb_id = info.get("external_ids", {}).get("tvdb_id")
             self.imdb_id = info.get("external_ids", {}).get("imdb_id")
+        # 合集ID
+        self.collection_id = info.get('collection_id')
         # 评分
         self.vote_average = round(float(info.get('vote_average')), 1) if info.get('vote_average') else 0
         # 描述
@@ -353,6 +415,14 @@ class MediaInfo:
         self.genre_ids = info.get('genre_ids') or []
         # 原语种
         self.original_language = info.get('original_language')
+        # 英文标题
+        self.en_title = info.get('en_title')
+        # 香港标题
+        self.hk_title = info.get('hk_title')
+        # 台湾标题
+        self.tw_title = info.get('tw_title')
+        # 新加坡标题
+        self.sg_title = info.get('sg_title')
         if self.type == MediaType.MOVIE:
             # 标题
             self.title = info.get('title')
@@ -388,6 +458,10 @@ class MediaInfo:
                     air_date = seainfo.get("air_date")
                     if air_date:
                         self.season_years[season] = air_date[:4]
+            # 剧集组
+            if info.get("episode_groups"):
+                self.episode_groups = info.pop("episode_groups").get("results") or []
+
         # 海报
         if info.get('poster_path'):
             self.poster_path = f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/original{info.get('poster_path')}"
@@ -409,29 +483,49 @@ class MediaInfo:
         """
         if not info:
             return
+        # 来源
+        self.source = "douban"
         # 本体
         self.douban_info = info
         # 豆瓣ID
         self.douban_id = str(info.get("id"))
         # 类型
-
         if not self.type:
             if isinstance(info.get('media_type'), MediaType):
                 self.type = info.get('media_type')
-            else:
+            elif info.get("subtype"):
+                self.type = MediaType.MOVIE if info.get("subtype") == "movie" else MediaType.TV
+            elif info.get("target_type"):
+                self.type = MediaType.MOVIE if info.get("target_type") == "movie" else MediaType.TV
+            elif info.get("type_name"):
+                self.type = MediaType(info.get("type_name"))
+            elif info.get("uri"):
+                self.type = MediaType.MOVIE if "/movie/" in info.get("uri") else MediaType.TV
+            elif info.get("type") and info.get("type") in ["movie", "tv"]:
                 self.type = MediaType.MOVIE if info.get("type") == "movie" else MediaType.TV
         # 标题
         if not self.title:
             self.title = info.get("title")
-            # 识别标题中的季
-            meta = MetaInfo(self.title)
-            self.season = meta.begin_season
+        # 英文标题，暂时不支持
+        if not self.en_title:
+            self.en_title = info.get('original_title')
         # 原语种标题
         if not self.original_title:
             self.original_title = info.get("original_title")
         # 年份
         if not self.year:
             self.year = info.get("year")[:4] if info.get("year") else None
+            if not self.year and info.get("extra"):
+                self.year = info.get("extra").get("year")
+        # 识别标题中的季
+        meta = MetaInfo(info.get("title"))
+        # 季
+        if not self.season:
+            self.season = meta.begin_season
+            if self.season:
+                self.type = MediaType.TV
+            elif not self.type:
+                self.type = MediaType.MOVIE
         # 评分
         if not self.vote_average:
             rating = info.get("rating")
@@ -452,14 +546,24 @@ class MediaInfo:
                         self.release_date = match.group()
         # 海报
         if not self.poster_path:
-            self.poster_path = info.get("pic", {}).get("large")
+            if info.get("pic"):
+                self.poster_path = info.get("pic", {}).get("large")
             if not self.poster_path and info.get("cover_url"):
-                self.poster_path = info.get("cover_url")
+                # imageView2/0/q/80/w/9999/h/120/format/webp ->  imageView2/1/w/500/h/750/format/webp
+                self.poster_path = re.sub(r'imageView2/\d/q/\d+/w/\d+/h/\d+/format/webp', 'imageView2/1/w/500/h/750/format/webp', info.get("cover_url"))
             if not self.poster_path and info.get("cover"):
-                self.poster_path = info.get("cover").get("url")
+                if info.get("cover").get("url"):
+                    self.poster_path = info.get("cover").get("url")
+                else:
+                    self.poster_path = info.get("cover").get("large", {}).get("url")
         # 简介
         if not self.overview:
             self.overview = info.get("intro") or info.get("card_subtitle") or ""
+            if not self.overview:
+                if info.get("extra", {}).get("info"):
+                    extra_info = info.get("extra").get("info")
+                    if extra_info:
+                        self.overview = "，".join(["：".join(item) for item in extra_info])
         # 从简介中提取年份
         if self.overview and not self.year:
             match = re.search(r'\d{4}', self.overview)
@@ -472,19 +576,107 @@ class MediaInfo:
             self.actors = info.get("actors") or []
         # 别名
         if not self.names:
-            self.names = info.get("aka") or []
+            akas = info.get("aka")
+            if akas:
+                self.names = [re.sub(r'\([港台豆友译名]+\)', "", aka) for aka in akas]
         # 剧集
         if self.type == MediaType.TV and not self.seasons:
             meta = MetaInfo(info.get("title"))
-            if meta.begin_season:
-                episodes_count = info.get("episodes_count")
-                if episodes_count:
-                    self.seasons[meta.begin_season] = list(range(1, episodes_count + 1))
+            season = meta.begin_season or 1
+            episodes_count = info.get("episodes_count")
+            if episodes_count:
+                self.seasons[season] = list(range(1, episodes_count + 1))
+        # 季年份
+        if self.type == MediaType.TV and not self.season_years:
+            season = self.season or 1
+            self.season_years = {
+                season: self.year
+            }
+        # 风格
+        if not self.genres:
+            self.genres = [{"id": genre, "name": genre} for genre in info.get("genres") or []]
+        # 时长
+        if not self.runtime and info.get("durations"):
+            # 查找数字
+            match = re.search(r'\d+', info.get("durations")[0])
+            if match:
+                self.runtime = int(match.group())
+        # 国家
+        if not self.production_countries:
+            self.production_countries = [{"id": country, "name": country} for country in info.get("countries") or []]
         # 剩余属性赋值
         for key, value in info.items():
             if not hasattr(self, key):
                 setattr(self, key, value)
 
+    def set_bangumi_info(self, info: dict):
+        """
+        初始化Bangumi信息
+        """
+        if not info:
+            return
+        # 来源
+        self.source = "bangumi"
+        # 本体
+        self.bangumi_info = info
+        # 豆瓣ID
+        self.bangumi_id = info.get("id")
+        # 类型
+        if not self.type:
+            self.type = MediaType.TV
+        # 标题
+        if not self.title:
+            self.title = info.get("name_cn") or info.get("name")
+        # 原语种标题
+        if not self.original_title:
+            self.original_title = info.get("name")
+        # 识别标题中的季
+        meta = MetaInfo(self.title)
+        # 季
+        if not self.season:
+            self.season = meta.begin_season
+        # 评分
+        if not self.vote_average:
+            rating = info.get("rating")
+            if rating:
+                vote_average = float(rating.get("score"))
+            else:
+                vote_average = 0
+            self.vote_average = vote_average
+        # 发行日期
+        if not self.release_date:
+            self.release_date = info.get("date") or info.get("air_date")
+            # 年份
+            if not self.year:
+                self.year = self.release_date[:4] if self.release_date else None
+        # 海报
+        if not self.poster_path:
+            if info.get("images"):
+                self.poster_path = info.get("images", {}).get("large")
+            if not self.poster_path and info.get("image"):
+                self.poster_path = info.get("image")
+        # 简介
+        if not self.overview:
+            self.overview = info.get("summary")
+        # 别名
+        if not self.names:
+            infobox = info.get("infobox")
+            if infobox:
+                akas = [item.get("value") for item in infobox if item.get("key") == "别名"]
+                if akas:
+                    self.names = [aka.get("v") for aka in akas[0]]
+
+        # 剧集
+        if self.type == MediaType.TV and not self.seasons:
+            meta = MetaInfo(self.title)
+            season = meta.begin_season or 1
+            episodes_count = info.get("total_episodes")
+            if episodes_count:
+                self.seasons[season] = list(range(1, episodes_count + 1))
+        # 演员
+        if not self.actors:
+            self.actors = info.get("actors") or []
+
     @property
     def title_year(self):
         if self.title:
@@ -503,6 +695,8 @@ class MediaInfo:
                 return "https://www.themoviedb.org/tv/%s" % self.tmdb_id
         elif self.douban_id:
             return "https://movie.douban.com/subject/%s" % self.douban_id
+        elif self.bangumi_id:
+            return "http://bgm.tv/subject/%s" % self.bangumi_id
         return ""
 
     @property
@@ -528,7 +722,7 @@ class MediaInfo:
             return self.backdrop_path.replace("original", "w500")
         return default or ""
 
-    def get_message_image(self, default: bool = None):
+    def get_message_image(self, default: Optional[bool] = None):
         """
         返回消息图片地址
         """
@@ -536,7 +730,7 @@ class MediaInfo:
             return self.backdrop_path.replace("original", "w500")
         return self.get_poster_image(default=default)
 
-    def get_poster_image(self, default: bool = None):
+    def get_poster_image(self, default: Optional[bool] = None):
         """
         返回海报图片地址
         """
@@ -544,7 +738,7 @@ class MediaInfo:
             return self.poster_path.replace("original", "w500")
         return default or ""
 
-    def get_overview_string(self, max_len: int = 140):
+    def get_overview_string(self, max_len: Optional[int] = 140):
         """
         返回带限定长度的简介信息
         :param max_len: 内容长度
@@ -560,10 +754,13 @@ class MediaInfo:
         """
         返回字典
         """
-        dicts = asdict(self)
+        dicts = vars(self).copy()
         dicts["type"] = self.type.value if self.type else None
         dicts["detail_link"] = self.detail_link
         dicts["title_year"] = self.title_year
+        dicts["tmdb_info"] = None
+        dicts["douban_info"] = None
+        dicts["bangumi_info"] = None
         return dicts
 
     def clear(self):
@@ -572,6 +769,7 @@ class MediaInfo:
         """
         self.tmdb_info = {}
         self.douban_info = {}
+        self.bangumi_info = {}
         self.seasons = {}
         self.genres = []
         self.season_info = []
@@ -583,6 +781,7 @@ class MediaInfo:
         self.spoken_languages = []
         self.networks = []
         self.next_episode_to_air = {}
+        self.episode_groups = []
 
 
 @dataclass

app/core/event.py

@@ -1,105 +1,559 @@
-from queue import Queue, Empty
+import copy
+import importlib
+import inspect
+import random
+import threading
+import time
+import traceback
+import uuid
+from queue import Empty, PriorityQueue
+from typing import Callable, Dict, List, Optional, Union
 
+from app.helper.thread import ThreadHelper
 from app.log import logger
+from app.schemas import ChainEventData
+from app.schemas.types import ChainEventType, EventType
+from app.utils.limit import ExponentialBackoffRateLimiter
 from app.utils.singleton import Singleton
-from app.schemas.types import EventType
+
+DEFAULT_EVENT_PRIORITY = 10  # 事件的默认优先级
+MIN_EVENT_CONSUMER_THREADS = 1  # 最小事件消费者线程数
+INITIAL_EVENT_QUEUE_IDLE_TIMEOUT_SECONDS = 1  # 事件队列空闲时的初始超时时间（秒）
+MAX_EVENT_QUEUE_IDLE_TIMEOUT_SECONDS = 5  # 事件队列空闲时的最大超时时间（秒）
+
+
+class Event:
+    """
+    事件类，封装事件的基本信息
+    """
+
+    def __init__(self, event_type: Union[EventType, ChainEventType],
+                 event_data: Optional[Union[Dict, ChainEventData]] = None,
+                 priority: Optional[int] = DEFAULT_EVENT_PRIORITY):
+        """
+        :param event_type: 事件的类型，支持 EventType 或 ChainEventType
+        :param event_data: 可选，事件携带的数据，默认为空字典
+        :param priority: 可选，事件的优先级，默认为 10
+        """
+        self.event_id = str(uuid.uuid4())  # 事件ID
+        self.event_type = event_type  # 事件类型
+        self.event_data = event_data or {}  # 事件数据
+        self.priority = priority  # 事件优先级
+
+    def __repr__(self) -> str:
+        """
+        重写 __repr__ 方法，用于返回事件的详细信息，包括事件类型、事件ID和优先级
+        """
+        event_kind = Event.get_event_kind(self.event_type)
+        return f"<{event_kind}: {self.event_type.value}, ID: {self.event_id}, Priority: {self.priority}>"
+
+    def __lt__(self, other):
+        """
+        定义事件对象的比较规则，基于优先级比较
+        优先级小的事件会被认为“更小”，优先级高的事件将被认为“更大”
+        """
+        return self.priority < other.priority
+
+    @staticmethod
+    def get_event_kind(event_type: Union[EventType, ChainEventType]) -> str:
+        """
+        根据事件类型判断事件是广播事件还是链式事件
+        :param event_type: 事件类型，支持 EventType 或 ChainEventType
+        :return: 返回 Broadcast Event 或 Chain Event
+        """
+        return "Broadcast Event" if isinstance(event_type, EventType) else "Chain Event"
 
 
 class EventManager(metaclass=Singleton):
     """
-    事件管理器
+    EventManager 负责管理和调度广播事件和链式事件，包括订阅、发送和处理事件
     """
 
-    # 事件队列
-    _eventQueue: Queue = None
-    # 事件响应函数字典
-    _handlers: dict = {}
+    # 退出事件
+    __event = threading.Event()
 
     def __init__(self):
-        # 事件队列
-        self._eventQueue = Queue()
-        # 事件响应函数字典
-        self._handlers = {}
+        self.__executor = ThreadHelper()  # 动态线程池，用于消费事件
+        self.__consumer_threads = []  # 用于保存启动的事件消费者线程
+        self.__event_queue = PriorityQueue()  # 优先级队列
+        self.__broadcast_subscribers: Dict[EventType, Dict[str, Callable]] = {}  # 广播事件的订阅者
+        self.__chain_subscribers: Dict[ChainEventType, Dict[str, tuple[int, Callable]]] = {}  # 链式事件的订阅者
+        self.__disabled_handlers = set()  # 禁用的事件处理器集合
+        self.__disabled_classes = set()  # 禁用的事件处理器类集合
+        self.__lock = threading.Lock()  # 线程锁
 
-    def get_event(self):
+    def start(self):
         """
-        获取事件
+        开始广播事件处理线程
         """
+        # 启动消费者线程用于处理广播事件
+        self.__event.set()
+        for _ in range(MIN_EVENT_CONSUMER_THREADS):
+            thread = threading.Thread(target=self.__broadcast_consumer_loop, daemon=True)
+            thread.start()
+            self.__consumer_threads.append(thread)  # 将线程对象保存到列表中
+
+    def stop(self):
+        """
+        停止广播事件处理线程
+        """
+        logger.info("正在停止事件处理...")
+        self.__event.clear()  # 停止广播事件处理
         try:
-            event = self._eventQueue.get(block=True, timeout=1)
-            handlerList = self._handlers.get(event.event_type)
-            return event, handlerList or []
-        except Empty:
-            return None, []
+            # 通过遍历保存的线程来等待它们完成
+            for consumer_thread in self.__consumer_threads:
+                consumer_thread.join()
+            logger.info("事件处理停止完成")
+        except Exception as e:
+            logger.error(f"停止事件处理线程出错：{str(e)} - {traceback.format_exc()}")
 
-    def add_event_listener(self, etype: EventType, handler: type):
+    def check(self, etype: Union[EventType, ChainEventType]) -> bool:
         """
-        注册事件处理
+        检查是否有启用的事件处理器可以响应某个事件类型
+        :param etype: 事件类型 (EventType 或 ChainEventType)
+        :return: 返回是否存在可用的处理器
         """
-        try:
-            handlerList = self._handlers[etype.value]
-        except KeyError:
-            handlerList = []
-            self._handlers[etype.value] = handlerList
-        if handler not in handlerList:
-            handlerList.append(handler)
-            logger.debug(f"Event Registed：{etype.value} - {handler}")
+        if isinstance(etype, ChainEventType):
+            handlers = self.__chain_subscribers.get(etype, {})
+            return any(
+                self.__is_handler_enabled(handler)
+                for _, handler in handlers.values()
+            )
+        else:
+            handlers = self.__broadcast_subscribers.get(etype, {})
+            return any(
+                self.__is_handler_enabled(handler)
+                for handler in handlers.values()
+            )
 
-    def remove_event_listener(self, etype: EventType, handler: type):
+    def send_event(self, etype: Union[EventType, ChainEventType], data: Optional[Union[Dict, ChainEventData]] = None,
+                   priority: Optional[int] = DEFAULT_EVENT_PRIORITY) -> Optional[Event]:
         """
-        移除监听器的处理函数
+        发送事件，根据事件类型决定是广播事件还是链式事件
+        :param etype: 事件类型 (EventType 或 ChainEventType)
+        :param data: 可选，事件数据
+        :param priority: 广播事件的优先级，默认为 10
+        :return: 如果是链式事件，返回处理后的事件数据；否则返回 None
         """
-        try:
-            handlerList = self._handlers[etype.value]
-            if handler in handlerList[:]:
-                handlerList.remove(handler)
-            if not handlerList:
-                del self._handlers[etype.value]
-        except KeyError:
-            pass
+        event = Event(etype, data, priority)
+        if isinstance(etype, EventType):
+            return self.__trigger_broadcast_event(event)
+        elif isinstance(etype, ChainEventType):
+            return self.__trigger_chain_event(event)
+        else:
+            logger.error(f"Unknown event type: {etype}")
+        return None
 
-    def send_event(self, etype: EventType, data: dict = None):
+    def add_event_listener(self, event_type: Union[EventType, ChainEventType], handler: Callable,
+                           priority: Optional[int] = DEFAULT_EVENT_PRIORITY):
         """
-        发送事件
+        注册事件处理器，将处理器添加到对应的事件订阅列表中
+        :param event_type: 事件类型 (EventType 或 ChainEventType)
+        :param handler: 处理器
+        :param priority: 可选，链式事件的优先级，默认为 10；广播事件不需要优先级
         """
-        if etype not in EventType:
-            return
-        event = Event(etype.value)
-        event.event_data = data or {}
-        logger.debug(f"发送事件：{etype.value} - {event.event_data}")
-        self._eventQueue.put(event)
+        with self.__lock:
+            handler_identifier = self.__get_handler_identifier(handler)
 
-    def register(self, etype: [EventType, list]):
-        """
-        事件注册
-        :param etype: 事件类型
-        """
-
-        def decorator(f):
-            if isinstance(etype, list):
-                for et in etype:
-                    self.add_event_listener(et, f)
-            elif type(etype) == type(EventType):
-                for et in etype.__members__.values():
-                    self.add_event_listener(et, f)
+            if isinstance(event_type, ChainEventType):
+                # 链式事件，按优先级排序
+                if event_type not in self.__chain_subscribers:
+                    self.__chain_subscribers[event_type] = {}
+                handlers = self.__chain_subscribers[event_type]
+                if handler_identifier in handlers:
+                    handlers.pop(handler_identifier)
+                else:
+                    logger.debug(
+                        f"Subscribed to chain event: {event_type.value}, "
+                        f"Priority: {priority} - {handler_identifier}")
+                handlers[handler_identifier] = (priority, handler)
+                # 根据优先级排序
+                self.__chain_subscribers[event_type] = dict(
+                    sorted(self.__chain_subscribers[event_type].items(), key=lambda x: x[1][0])
+                )
             else:
-                self.add_event_listener(etype, f)
+                # 广播事件
+                if event_type not in self.__broadcast_subscribers:
+                    self.__broadcast_subscribers[event_type] = {}
+                handlers = self.__broadcast_subscribers[event_type]
+                if handler_identifier in handlers:
+                    handlers.pop(handler_identifier)
+                else:
+                    logger.debug(f"Subscribed to broadcast event: {event_type.value} - {handler_identifier}")
+                handlers[handler_identifier] = handler
+
+    def remove_event_listener(self, event_type: Union[EventType, ChainEventType], handler: Callable):
+        """
+        移除事件处理器，将处理器从对应事件的订阅列表中删除
+        :param event_type: 事件类型 (EventType 或 ChainEventType)
+        :param handler: 要移除的处理器
+        """
+        with self.__lock:
+            handler_identifier = self.__get_handler_identifier(handler)
+
+            if isinstance(event_type, ChainEventType) and event_type in self.__chain_subscribers:
+                self.__chain_subscribers[event_type].pop(handler_identifier, None)
+                logger.debug(f"Unsubscribed from chain event: {event_type.value} - {handler_identifier}")
+            elif event_type in self.__broadcast_subscribers:
+                self.__broadcast_subscribers[event_type].pop(handler_identifier, None)
+                logger.debug(f"Unsubscribed from broadcast event: {event_type.value} - {handler_identifier}")
+
+    def disable_event_handler(self, target: Union[Callable, type]):
+        """
+        禁用指定的事件处理器或事件处理器类
+        :param target: 处理器函数或类
+        """
+        identifier = self.__get_handler_identifier(target)
+        if identifier in self.__disabled_handlers or identifier in self.__disabled_classes:
+            return
+        if isinstance(target, type):
+            self.__disabled_classes.add(identifier)
+            logger.debug(f"Disabled event handler class - {identifier}")
+        else:
+            self.__disabled_handlers.add(identifier)
+            logger.debug(f"Disabled event handler - {identifier}")
+
+    def enable_event_handler(self, target: Union[Callable, type]):
+        """
+        启用指定的事件处理器或事件处理器类
+        :param target: 处理器函数或类
+        """
+        identifier = self.__get_handler_identifier(target)
+        if isinstance(target, type):
+            self.__disabled_classes.discard(identifier)
+            logger.debug(f"Enabled event handler class - {identifier}")
+        else:
+            self.__disabled_handlers.discard(identifier)
+            logger.debug(f"Enabled event handler - {identifier}")
+
+    def visualize_handlers(self) -> List[Dict]:
+        """
+        可视化所有事件处理器，包括是否被禁用的状态
+        :return: 处理器列表，包含事件类型、处理器标识符、优先级（如果有）和状态
+        """
+
+        def parse_handler_data(data):
+            """
+            解析处理器数据，判断是否包含优先级
+            :param data: 订阅者数据，可能是元组或单一值
+            :return: (priority, handler)，若没有优先级则返回 (None, handler)
+            """
+            if isinstance(data, tuple) and len(data) == 2:
+                return data
+            return None, data
+
+        handler_info = []
+        # 统一处理广播事件和链式事件
+        for event_type, subscribers in {**self.__broadcast_subscribers, **self.__chain_subscribers}.items():
+            for handler_identifier, handler_data in subscribers.items():
+                # 解析优先级和处理器
+                priority, handler = parse_handler_data(handler_data)
+                # 检查处理器的启用状态
+                status = "enabled" if self.__is_handler_enabled(handler) else "disabled"
+                # 构建处理器信息字典
+                handler_dict = {
+                    "event_type": event_type.value,
+                    "handler_identifier": handler_identifier,
+                    "status": status
+                }
+                if priority is not None:
+                    handler_dict["priority"] = priority
+                handler_info.append(handler_dict)
+        return handler_info
+
+    @classmethod
+    def __get_handler_identifier(cls, target: Union[Callable, type]) -> Optional[str]:
+        """
+        获取处理器或处理器类的唯一标识符，包括模块名和类名/方法名
+        :param target: 处理器函数或类
+        :return: 唯一标识符
+        """
+        # 统一使用 inspect.getmodule 来获取模块名
+        module = inspect.getmodule(target)
+        module_name = module.__name__ if module else "unknown_module"
+
+        # 使用 __qualname__ 获取目标的限定名
+        qualname = target.__qualname__
+        return f"{module_name}.{qualname}"
+
+    @classmethod
+    def __get_class_from_callable(cls, handler: Callable) -> Optional[str]:
+        """
+        获取可调用对象所属类的唯一标识符
+        :param handler: 可调用对象（函数、方法等）
+        :return: 类的唯一标识符
+        """
+        # 对于绑定方法，通过 __self__.__class__ 获取类
+        if inspect.ismethod(handler) and hasattr(handler, "__self__"):
+            return cls.__get_handler_identifier(handler.__self__.__class__)
+
+        # 对于类实例（实现了 __call__ 方法）
+        if not inspect.isfunction(handler) and hasattr(handler, "__call__"):
+            handler_cls = handler.__class__  # noqa
+            return cls.__get_handler_identifier(handler_cls)
+
+        # 对于未绑定方法、静态方法、类方法，使用 __qualname__ 提取类信息
+        qualname_parts = handler.__qualname__.split(".")
+        if len(qualname_parts) > 1:
+            class_name = ".".join(qualname_parts[:-1])
+            module = inspect.getmodule(handler)
+            module_name = module.__name__ if module else "unknown_module"
+            return f"{module_name}.{class_name}"
+        return None
+
+    def __is_handler_enabled(self, handler: Callable) -> bool:
+        """
+        检查处理器是否已启用（没有被禁用）
+        :param handler: 处理器函数
+        :return: 如果处理器启用则返回 True，否则返回 False
+        """
+        # 获取处理器的唯一标识符
+        handler_id = self.__get_handler_identifier(handler)
+
+        # 获取处理器所属类的唯一标识符
+        class_id = self.__get_class_from_callable(handler)
+
+        # 检查处理器或类是否被禁用，只要其中之一被禁用则返回 False
+        if handler_id in self.__disabled_handlers or (class_id is not None and class_id in self.__disabled_classes):
+            return False
+
+        return True
+
+    def __trigger_chain_event(self, event: Event) -> Optional[Event]:
+        """
+        触发链式事件，按顺序调用订阅的处理器，并记录处理耗时
+        """
+        logger.debug(f"Triggering synchronous chain event: {event}")
+        dispatch = self.__dispatch_chain_event(event)
+        return event if dispatch else None
+
+    def __trigger_broadcast_event(self, event: Event):
+        """
+        触发广播事件，将事件插入到优先级队列中
+        :param event: 要处理的事件对象
+        """
+        logger.debug(f"Triggering broadcast event: {event}")
+        self.__event_queue.put((event.priority, event))
+
+    def __dispatch_chain_event(self, event: Event) -> bool:
+        """
+        同步方式调度链式事件，按优先级顺序逐个调用事件处理器，并记录每个处理器的处理时间
+        :param event: 要调度的事件对象
+        """
+        handlers = self.__chain_subscribers.get(event.event_type, {})
+        if not handlers:
+            logger.debug(f"No handlers found for chain event: {event}")
+            return False
+
+        # 过滤出启用的处理器
+        enabled_handlers = {handler_id: (priority, handler) for handler_id, (priority, handler) in handlers.items()
+                            if self.__is_handler_enabled(handler)}
+
+        if not enabled_handlers:
+            logger.debug(f"No enabled handlers found for chain event: {event}. Skipping execution.")
+            return False
+
+        self.__log_event_lifecycle(event, "Started")
+        for handler_id, (priority, handler) in enabled_handlers.items():
+            start_time = time.time()
+            self.__safe_invoke_handler(handler, event)
+            logger.debug(
+                f"{self.__get_handler_identifier(handler)} (Priority: {priority}), "
+                f"completed in {time.time() - start_time:.3f}s for event: {event}"
+            )
+        self.__log_event_lifecycle(event, "Completed")
+        return True
+
+    def __dispatch_broadcast_event(self, event: Event):
+        """
+        异步方式调度广播事件，通过线程池逐个调用事件处理器
+        :param event: 要调度的事件对象
+        """
+        handlers = self.__broadcast_subscribers.get(event.event_type, {})
+        if not handlers:
+            logger.debug(f"No handlers found for broadcast event: {event}")
+            return
+        for handler_id, handler in handlers.items():
+            self.__executor.submit(self.__safe_invoke_handler, handler, event)
+
+    def __safe_invoke_handler(self, handler: Callable, event: Event):
+        """
+        调用处理器，处理链式或广播事件
+        :param handler: 处理器
+        :param event: 事件对象
+        """
+        if not self.__is_handler_enabled(handler):
+            logger.debug(f"Handler {self.__get_handler_identifier(handler)} is disabled. Skipping execution")
+            return
+
+        # 根据事件类型判断是否需要深复制
+        is_broadcast_event = isinstance(event.event_type, EventType)
+        event_to_process = copy.deepcopy(event) if is_broadcast_event else event
+
+        names = handler.__qualname__.split(".")
+        class_name, method_name = names[0], names[1]
+
+        try:
+            from app.core.plugin import PluginManager
+            from app.core.module import ModuleManager
+
+            if class_name in PluginManager().get_plugin_ids():
+                def plugin_callable():
+                    """
+                    插件调用函数
+                    """
+                    PluginManager().run_plugin_method(class_name, method_name, event_to_process)
+
+                if is_broadcast_event:
+                    self.__executor.submit(plugin_callable)
+                else:
+                    plugin_callable()
+            elif class_name in ModuleManager().get_module_ids():
+                module = ModuleManager().get_running_module(class_name)
+                if module:
+                    method = getattr(module, method_name, None)
+                    if method:
+                        if is_broadcast_event:
+                            self.__executor.submit(method, event_to_process)
+                        else:
+                            method(event_to_process)
+            else:
+                # 获取全局对象或模块类的实例
+                class_obj = self.__get_class_instance(class_name)
+                if class_obj and hasattr(class_obj, method_name):
+                    method = getattr(class_obj, method_name)
+                    if is_broadcast_event:
+                        self.__executor.submit(method, event_to_process)
+                    else:
+                        method(event_to_process)
+        except Exception as e:
+            self.__handle_event_error(event, handler, e)
+
+    @staticmethod
+    def __get_class_instance(class_name: str):
+        """
+        根据类名获取类实例，首先检查全局变量中是否存在该类，如果不存在则尝试动态导入模块。
+        :param class_name: 类的名称
+        :return: 类的实例
+        """
+        # 检查类是否在全局变量中
+        if class_name in globals():
+            try:
+                class_obj = globals()[class_name]()
+                return class_obj
+            except Exception as e:
+                logger.error(f"事件处理出错：创建全局类实例出错：{str(e)} - {traceback.format_exc()}")
+                return None
+
+        # 如果类不在全局变量中，尝试动态导入模块并创建实例
+        try:
+            if class_name.endswith("Manager"):
+                module_name = f"app.core.{class_name[:-7].lower()}"
+                module = importlib.import_module(module_name)
+            elif class_name.endswith("Chain"):
+                module_name = f"app.chain.{class_name[:-5].lower()}"
+                module = importlib.import_module(module_name)
+            elif class_name.endswith("Helper"):
+                module_name = f"app.helper.{class_name[:-6].lower()}"
+                module = importlib.import_module(module_name)
+            else:
+                module_name = f"app.{class_name.lower()}"
+                module = importlib.import_module(module_name)
+            if hasattr(module, class_name):
+                class_obj = getattr(module, class_name)()
+                return class_obj
+            else:
+                logger.debug(f"事件处理出错：模块 {module_name} 中没有找到类 {class_name}")
+        except Exception as e:
+            logger.debug(f"事件处理出错：{str(e)} - {traceback.format_exc()}")
+        return None
+
+    def __broadcast_consumer_loop(self):
+        """
+        持续从队列中提取事件的后台广播消费者线程
+        """
+        jitter_factor = 0.1
+        rate_limiter = ExponentialBackoffRateLimiter(base_wait=INITIAL_EVENT_QUEUE_IDLE_TIMEOUT_SECONDS,
+                                                     max_wait=MAX_EVENT_QUEUE_IDLE_TIMEOUT_SECONDS,
+                                                     backoff_factor=2.0,
+                                                     source="BroadcastConsumer",
+                                                     enable_logging=False)
+        while self.__event.is_set():
+            try:
+                priority, event = self.__event_queue.get(timeout=rate_limiter.current_wait)
+                rate_limiter.reset()
+                self.__dispatch_broadcast_event(event)
+            except Empty:
+                rate_limiter.current_wait = rate_limiter.current_wait * random.uniform(1, 1 + jitter_factor)
+                rate_limiter.trigger_limit()
+
+    @staticmethod
+    def __log_event_lifecycle(event: Event, stage: str):
+        """
+        记录事件的生命周期日志
+        """
+        logger.debug(f"{stage} - {event}")
+
+    def __handle_event_error(self, event: Event, handler: Callable, e: Exception):
+        """
+        全局错误处理器，用于处理事件处理中的异常
+        """
+        logger.error(f"事件处理出错：{str(e)} - {traceback.format_exc()}")
+
+        names = handler.__qualname__.split(".")
+        class_name, method_name = names[0], names[1]
+
+        # 发送系统错误通知
+        from app.helper.message import MessageHelper
+        MessageHelper().put(title=f"{event.event_type} 事件处理出错",
+                            message=f"{class_name}.{method_name}：{str(e)}",
+                            role="system")
+        self.send_event(
+            EventType.SystemError,
+            {
+                "type": "event",
+                "event_type": event.event_type,
+                "event_handle": f"{class_name}.{method_name}",
+                "error": str(e),
+                "traceback": traceback.format_exc()
+            }
+        )
+
+    def register(self, etype: Union[EventType, ChainEventType, List[Union[EventType, ChainEventType]], type],
+                 priority: Optional[int] = DEFAULT_EVENT_PRIORITY):
+        """
+        事件注册装饰器，用于将函数注册为事件的处理器
+        :param etype:
+            - 单个事件类型成员 (如 EventType.MetadataScrape, ChainEventType.PluginAction)
+            - 事件类型类 (EventType, ChainEventType)
+            - 或事件类型成员的列表
+        :param priority: 可选，链式事件的优先级，默认为 DEFAULT_EVENT_PRIORITY
+        """
+
+        def decorator(f: Callable):
+            # 将输入的事件类型统一转换为列表格式
+            if isinstance(etype, list):
+                # 传入的已经是列表，直接使用
+                event_list = etype
+            else:
+                # 不是列表则包裹成单一元素的列表
+                event_list = [etype]
+
+            # 遍历列表，处理每个事件类型
+            for event in event_list:
+                if isinstance(event, (EventType, ChainEventType)):
+                    self.add_event_listener(event, f, priority)
+                elif isinstance(event, type) and issubclass(event, (EventType, ChainEventType)):
+                    # 如果是 EventType 或 ChainEventType 类，提取该类中的所有成员
+                    for et in event.__members__.values():
+                        self.add_event_listener(et, f, priority)
+                else:
+                    raise ValueError(f"无效的事件类型: {event}")
+
             return f
 
         return decorator
 
 
-class Event(object):
-    """
-    事件对象
-    """
-
-    def __init__(self, event_type=None):
-        # 事件类型
-        self.event_type = event_type
-        # 字典用于保存具体的事件数据
-        self.event_data = {}
-
-
-# 实例引用，用于注册事件
+# 全局实例定义
 eventmanager = EventManager()

app/core/meta/customization.py

@@ -0,0 +1,47 @@
+import regex as re
+
+from app.db.systemconfig_oper import SystemConfigOper
+from app.schemas.types import SystemConfigKey
+from app.utils.singleton import Singleton
+
+
+class CustomizationMatcher(metaclass=Singleton):
+    """
+    识别自定义占位符
+    """
+    customization = None
+    custom_separator = None
+
+    def __init__(self):
+        self.systemconfig = SystemConfigOper()
+        self.customization = None
+        self.custom_separator = None
+
+    def match(self, title=None):
+        """
+        :param title: 资源标题或文件名
+        :return: 匹配结果
+        """
+        if not title:
+            return ""
+        if not self.customization:
+            # 自定义占位符
+            customization = self.systemconfig.get(SystemConfigKey.Customization)
+            if not customization:
+                return ""
+            if isinstance(customization, str):
+                customization = customization.replace("\n", ";").replace("|", ";").strip(";").split(";")
+            self.customization = "|".join([f"({item})" for item in customization])
+
+        customization_re = re.compile(r"%s" % self.customization)
+        # 处理重复多次的情况，保留先后顺序（按添加自定义占位符的顺序）
+        unique_customization = {}
+        for item in re.findall(customization_re, title):
+            if not isinstance(item, tuple):
+                item = (item,)
+            for i in range(len(item)):
+                if item[i] and unique_customization.get(item[i]) is None:
+                    unique_customization[item[i]] = i
+        unique_customization = list(dict(sorted(unique_customization.items(), key=lambda x: x[1])).keys())
+        separator = self.custom_separator or "@"
+        return separator.join(unique_customization)

app/core/meta/metaanime.py

@@ -1,8 +1,12 @@
 import re
+import traceback
+
 import zhconv
 import anitopy
+from app.core.meta.customization import CustomizationMatcher
 from app.core.meta.metabase import MetaBase
 from app.core.meta.releasegroup import ReleaseGroupsMatcher
+from app.log import logger
 from app.utils.string import StringUtils
 from app.schemas.types import MediaType
 
@@ -12,7 +16,7 @@ class MetaAnime(MetaBase):
     识别动漫
     """
     _anime_no_words = ['CHS&CHT', 'MP4', 'GB MP4', 'WEB-DL']
-    _name_nostring_re = r"S\d{2}\s*-\s*S\d{2}|S\d{2}|\s+S\d{1,2}|EP?\d{2,4}\s*-\s*EP?\d{2,4}|EP?\d{2,4}|\s+EP?\d{1,4}"
+    _name_nostring_re = r"S\d{2}\s*-\s*S\d{2}|S\d{2}|\s+S\d{1,2}|EP?\d{2,4}\s*-\s*EP?\d{2,4}|EP?\d{2,4}|\s+EP?\d{1,4}|\s+GB"
 
     def __init__(self, title: str, subtitle: str = None, isfile: bool = False):
         super().__init__(title, subtitle, isfile)
@@ -28,8 +32,6 @@ class MetaAnime(MetaBase):
             if anitopy_info:
                 # 名称
                 name = anitopy_info.get("anime_title")
-                if name and name.find("/") != -1:
-                    name = name.split("/")[-1].strip()
                 if not name or name in self._anime_no_words or (len(name) < 5 and not StringUtils.is_chinese(name)):
                     anitopy_info = anitopy.parse("[ANIME]" + title)
                     if anitopy_info:
@@ -40,28 +42,45 @@ class MetaAnime(MetaBase):
                         name = name_match.group(1).strip()
                 # 拆份中英文名称
                 if name:
-                    lastword_type = ""
-                    for word in name.split():
-                        if not word:
-                            continue
-                        if word.endswith(']'):
-                            word = word[:-1]
-                        if word.isdigit():
-                            if lastword_type == "cn":
-                                self.cn_name = "%s %s" % (self.cn_name or "", word)
-                            elif lastword_type == "en":
-                                self.en_name = "%s %s" % (self.en_name or "", word)
-                        elif StringUtils.is_chinese(word):
-                            self.cn_name = "%s %s" % (self.cn_name or "", word)
-                            lastword_type = "cn"
+                    _split_flag = True
+                    # 按/拆分中英文
+                    if name.find("/") != -1:
+                        names = name.split("/")
+                        if StringUtils.is_chinese(names[0]):
+                            self.cn_name = names[0]
+                            if len(names) > 1:
+                                self.en_name = names[1]
+                            _split_flag = False
+                        elif StringUtils.is_chinese(names[-1]):
+                            self.cn_name = names[-1]
+                            if len(names) > 1:
+                                self.en_name = names[0]
+                            _split_flag = False
                         else:
-                            self.en_name = "%s %s" % (self.en_name or "", word)
-                            lastword_type = "en"
+                            name = names[-1]
+                    # 拆分中英文
+                    if _split_flag:
+                        lastword_type = ""
+                        for word in name.split():
+                            if not word:
+                                continue
+                            if word.endswith(']'):
+                                word = word[:-1]
+                            if word.isdigit():
+                                if lastword_type == "cn":
+                                    self.cn_name = "%s %s" % (self.cn_name or "", word)
+                                elif lastword_type == "en":
+                                    self.en_name = "%s %s" % (self.en_name or "", word)
+                            elif StringUtils.is_chinese(word):
+                                self.cn_name = "%s %s" % (self.cn_name or "", word)
+                                lastword_type = "cn"
+                            else:
+                                self.en_name = "%s %s" % (self.en_name or "", word)
+                                lastword_type = "en"
                 if self.cn_name:
                     _, self.cn_name, _, _, _, _ = StringUtils.get_keyword(self.cn_name)
                     if self.cn_name:
                         self.cn_name = re.sub(r'%s' % self._name_nostring_re, '', self.cn_name, flags=re.IGNORECASE).strip()
-                        self.cn_name = zhconv.convert(self.cn_name, "zh-hans")
                 if self.en_name:
                     self.en_name = re.sub(r'%s' % self._name_nostring_re, '', self.en_name, flags=re.IGNORECASE).strip().title()
                     self._name = StringUtils.str_title(self.en_name)
@@ -116,7 +135,7 @@ class MetaAnime(MetaBase):
                         else:
                             self.total_episode = 1
                     except Exception as err:
-                        print(str(err))
+                        logger.debug(f"解析集数失败：{str(err)} - {traceback.format_exc()}")
                         self.begin_episode = None
                         self.end_episode = None
                     self.type = MediaType.TV
@@ -144,6 +163,8 @@ class MetaAnime(MetaBase):
                 self.resource_team = \
                     ReleaseGroupsMatcher().match(title=original_title) or \
                     anitopy_info_origin.get("release_group") or None
+                # 自定义占位符
+                self.customization = CustomizationMatcher().match(title=original_title) or None
                 # 视频编码
                 self.video_encode = anitopy_info.get("video_term")
                 if isinstance(self.video_encode, list):
@@ -159,7 +180,7 @@ class MetaAnime(MetaBase):
             if not self.type:
                 self.type = MediaType.TV
         except Exception as e:
-            print(str(e))
+            logger.error(f"解析动漫信息失败：{str(e)} - {traceback.format_exc()}")
 
     @staticmethod
     def __prepare_title(title: str):

app/core/meta/metabase.py

@@ -1,11 +1,13 @@
-from dataclasses import dataclass, asdict
+import traceback
+from dataclasses import dataclass
 from typing import Union, Optional, List, Self
 
 import cn2an
 import regex as re
 
-from app.utils.string import StringUtils
+from app.log import logger
 from app.schemas.types import MediaType
+from app.utils.string import StringUtils
 
 
 @dataclass
@@ -51,25 +53,32 @@ class MetaBase(object):
     resource_pix: Optional[str] = None
     # 识别的制作组/字幕组
     resource_team: Optional[str] = None
+    # 识别的自定义占位符
+    customization: Optional[str] = None
     # 视频编码
     video_encode: Optional[str] = None
     # 音频编码
     audio_encode: Optional[str] = None
     # 应用的识别词信息
     apply_words: Optional[List[str]] = None
+    # 附加信息
+    tmdbid: int = None
+    doubanid: str = None
 
     # 副标题解析
     _subtitle_flag = False
+    _title_episodel_re = r"Episode\s+(\d{1,4})"
     _subtitle_season_re = r"(?<![全共]\s*)[第\s]+([0-9一二三四五六七八九十S\-]+)\s*季(?!\s*[全共])"
-    _subtitle_season_all_re = r"[全共]\s*([0-9一二三四五六七八九十]+)\s*季|([0-9一二三四五六七八九十]+)\s*季\s*全"
-    _subtitle_episode_re = r"(?<![全共]\s*)[第\s]+([0-9一二三四五六七八九十百零EP\-]+)\s*[集话話期](?!\s*[全共])"
-    _subtitle_episode_all_re = r"([0-9一二三四五六七八九十百零]+)\s*集\s*全|[全共]\s*([0-9一二三四五六七八九十百零]+)\s*[集话話期]"
+    _subtitle_season_all_re = r"[全共]\s*([0-9一二三四五六七八九十]+)\s*季"
+    _subtitle_episode_re = r"(?<![全共]\s*)[第\s]+([0-9一二三四五六七八九十百零EP]+)\s*[集话話期幕](?!\s*[全共])"
+    _subtitle_episode_between_re = r"[第]*\s*([0-9一二三四五六七八九十百零]+)\s*[集话話期幕]?\s*-\s*第*\s*([0-9一二三四五六七八九十百零]+)\s*[集话話期幕]"
+    _subtitle_episode_all_re = r"([0-9一二三四五六七八九十百零]+)\s*集\s*全|[全共]\s*([0-9一二三四五六七八九十百零]+)\s*[集话話期幕]"
 
     def __init__(self, title: str, subtitle: str = None, isfile: bool = False):
         if not title:
             return
-        self.org_string = title
-        self.subtitle = subtitle
+        self.org_string = title.strip() if title else None
+        self.subtitle = subtitle.strip() if subtitle else None
         self.isfile = isfile
 
     @property
@@ -85,6 +94,17 @@ class MetaBase(object):
             return self.cn_name
         return ""
 
+    @name.setter
+    def name(self, name: str):
+        """
+        设置名称
+        """
+        if StringUtils.is_all_chinese(name):
+            self.cn_name = name
+        else:
+            self.en_name = name
+            self.cn_name = None
+
     def init_subtitle(self, title_text: str):
         """
         副标题识别
@@ -92,7 +112,39 @@ class MetaBase(object):
         if not title_text:
             return
         title_text = f" {title_text} "
-        if re.search(r'[全第季集话話期]', title_text, re.IGNORECASE):
+        if re.search(r"%s" % self._title_episodel_re, title_text, re.IGNORECASE):
+            episode_str = re.search(r'%s' % self._title_episodel_re, title_text, re.IGNORECASE)
+            if episode_str:
+                try:
+                    episode = int(episode_str.group(1))
+                except Exception as err:
+                    logger.debug(f'识别集失败：{str(err)} - {traceback.format_exc()}')
+                    return
+                if episode >= 10000:
+                    return
+                if self.begin_episode is None:
+                    self.begin_episode = episode
+                    self.total_episode = 1
+                self.type = MediaType.TV
+                self._subtitle_flag = True
+        elif re.search(r'[全第季集话話期幕]', title_text, re.IGNORECASE):
+            # 全x季 x季全
+            season_all_str = re.search(r"%s" % self._subtitle_season_all_re, title_text, re.IGNORECASE)
+            if season_all_str:
+                season_all = season_all_str.group(1)
+                if not season_all:
+                    season_all = season_all_str.group(2)
+                if season_all and self.begin_season is None and self.begin_episode is None:
+                    try:
+                        self.total_season = int(cn2an.cn2an(season_all.strip(), mode='smart'))
+                    except Exception as err:
+                        logger.debug(f'识别季失败：{str(err)} - {traceback.format_exc()}')
+                        return
+                    self.begin_season = 1
+                    self.end_season = self.total_season
+                    self.type = MediaType.TV
+                    self._subtitle_flag = True
+                return
             # 第x季
             season_str = re.search(r'%s' % self._subtitle_season_re, title_text, re.IGNORECASE)
             if season_str:
@@ -111,7 +163,11 @@ class MetaBase(object):
                     else:
                         begin_season = int(cn2an.cn2an(seasons, mode='smart'))
                 except Exception as err:
-                    print(str(err))
+                    logger.debug(f'识别季失败：{str(err)} - {traceback.format_exc()}')
+                    return
+                if begin_season and begin_season > 100:
+                    return
+                if end_season and end_season > 100:
                     return
                 if self.begin_season is None and isinstance(begin_season, int):
                     self.begin_season = begin_season
@@ -124,6 +180,37 @@ class MetaBase(object):
                     self.total_season = (self.end_season - self.begin_season) + 1
                 self.type = MediaType.TV
                 self._subtitle_flag = True
+            # 第x-x集 第x集-x集
+            episode_between_str = re.search(r'%s' % self._subtitle_episode_between_re, title_text, re.IGNORECASE)
+            if episode_between_str:
+                episodes = episode_between_str.groups()
+                if episodes:
+                    begin_episode = episodes[0]
+                    end_episode = episodes[1]
+                else:
+                    return
+                try:
+                    begin_episode = int(cn2an.cn2an(begin_episode.strip(), mode='smart'))
+                    end_episode = int(cn2an.cn2an(end_episode.strip(), mode='smart'))
+                except Exception as err:
+                    logger.debug(f'识别集失败：{str(err)} - {traceback.format_exc()}')
+                    return
+                if begin_episode and begin_episode >= 10000:
+                    return
+                if end_episode and end_episode >= 10000:
+                    return
+                if self.begin_episode is None and isinstance(begin_episode, int):
+                    self.begin_episode = begin_episode
+                    self.total_episode = 1
+                if self.begin_episode is not None \
+                        and self.end_episode is None \
+                        and isinstance(end_episode, int) \
+                        and end_episode != self.begin_episode:
+                    self.end_episode = end_episode
+                    self.total_episode = (self.end_episode - self.begin_episode) + 1
+                self.type = MediaType.TV
+                self._subtitle_flag = True
+                return
             # 第x集
             episode_str = re.search(r'%s' % self._subtitle_episode_re, title_text, re.IGNORECASE)
             if episode_str:
@@ -142,7 +229,11 @@ class MetaBase(object):
                     else:
                         begin_episode = int(cn2an.cn2an(episodes, mode='smart'))
                 except Exception as err:
-                    print(str(err))
+                    logger.debug(f'识别集失败：{str(err)} - {traceback.format_exc()}')
+                    return
+                if begin_episode and begin_episode >= 10000:
+                    return
+                if end_episode and end_episode >= 10000:
                     return
                 if self.begin_episode is None and isinstance(begin_episode, int):
                     self.begin_episode = begin_episode
@@ -155,7 +246,8 @@ class MetaBase(object):
                     self.total_episode = (self.end_episode - self.begin_episode) + 1
                 self.type = MediaType.TV
                 self._subtitle_flag = True
-            # x集全
+                return
+            # x集全/全x集
             episode_all_str = re.search(r'%s' % self._subtitle_episode_all_re, title_text, re.IGNORECASE)
             if episode_all_str:
                 episode_all = episode_all_str.group(1)
@@ -165,28 +257,11 @@ class MetaBase(object):
                     try:
                         self.total_episode = int(cn2an.cn2an(episode_all.strip(), mode='smart'))
                     except Exception as err:
-                        print(str(err))
+                        logger.debug(f'识别集失败：{str(err)} - {traceback.format_exc()}')
                         return
-                    self.begin_episode = None
-                    self.end_episode = None
-                    self.type = MediaType.TV
-                    self._subtitle_flag = True
-            # 全x季 x季全
-            season_all_str = re.search(r"%s" % self._subtitle_season_all_re, title_text, re.IGNORECASE)
-            if season_all_str:
-                season_all = season_all_str.group(1)
-                if not season_all:
-                    season_all = season_all_str.group(2)
-                if season_all and self.begin_season is None and self.begin_episode is None:
-                    try:
-                        self.total_season = int(cn2an.cn2an(season_all.strip(), mode='smart'))
-                    except Exception as err:
-                        print(str(err))
-                        return
-                    self.begin_season = 1
-                    self.end_season = self.total_season
                     self.type = MediaType.TV
                     self._subtitle_flag = True
+                return
 
     @property
     def season(self) -> str:
@@ -214,7 +289,7 @@ class MetaBase(object):
             return self.season
         else:
             return ""
-    
+
     @property
     def season_seq(self) -> str:
         """
@@ -257,7 +332,7 @@ class MetaBase(object):
                          str(self.end_episode).rjust(2, "0"))
         else:
             return ""
-    
+
     @property
     def episode_list(self) -> List[int]:
         """
@@ -455,7 +530,7 @@ class MetaBase(object):
             self.end_episode = end
         if self.begin_episode and self.end_episode:
             self.total_episode = (self.end_episode - self.begin_episode) + 1
-            
+
     def merge(self, meta: Self):
         """
         全并Meta信息
@@ -473,13 +548,13 @@ class MetaBase(object):
             self.year = meta.year
         # 季
         if (self.type == MediaType.TV
-                and not self.season):
+                and self.begin_season is None):
             self.begin_season = meta.begin_season
             self.end_season = meta.end_season
             self.total_season = meta.total_season
         # 开始集
         if (self.type == MediaType.TV
-                and not self.episode):
+                and self.begin_episode is None):
             self.begin_episode = meta.begin_episode
             self.end_episode = meta.end_episode
             self.total_episode = meta.total_episode
@@ -492,6 +567,9 @@ class MetaBase(object):
         # 制作组/字幕组
         if not self.resource_team:
             self.resource_team = meta.resource_team
+        # 自定义占位符
+        if not self.customization:
+            self.customization = meta.customization
         # 特效
         if not self.resource_effect:
             self.resource_effect = meta.resource_effect
@@ -504,14 +582,21 @@ class MetaBase(object):
         # Part
         if not self.part:
             self.part = meta.part
+        # tmdbid
+        if not self.tmdbid and meta.tmdbid:
+            self.tmdbid = meta.tmdbid
+        # doubanid
+        if not self.doubanid and meta.doubanid:
+            self.doubanid = meta.doubanid
 
     def to_dict(self):
         """
         转为字典
         """
-        dicts = asdict(self)
+        dicts = vars(self).copy()
         dicts["type"] = self.type.value if self.type else None
         dicts["season_episode"] = self.season_episode
         dicts["edition"] = self.edition
         dicts["name"] = self.name
+        dicts["episode_list"] = self.episode_list
         return dicts

app/core/meta/metavideo.py

@@ -1,12 +1,16 @@
 import re
-from pathlib import Path
+from typing import Optional
+
+from Pinyin2Hanzi import is_pinyin
 
 from app.core.config import settings
+from app.core.meta.customization import CustomizationMatcher
 from app.core.meta.metabase import MetaBase
 from app.core.meta.releasegroup import ReleaseGroupsMatcher
+from app.schemas.types import MediaType
 from app.utils.string import StringUtils
 from app.utils.tokens import Tokens
-from app.schemas.types import MediaType
+from app.core.meta.streamingplatform import StreamingPlatforms
 
 
 class MetaVideo(MetaBase):
@@ -23,47 +27,64 @@ class MetaVideo(MetaBase):
     _source = ""
     _effect = []
     # 正则式区
-    _season_re = r"S(\d{2})|^S(\d{1,2})$|S(\d{1,2})E"
+    _season_re = r"S(\d{3})|^S(\d{1,3})$|S(\d{1,3})E"
     _episode_re = r"EP?(\d{2,4})$|^EP?(\d{1,4})$|^S\d{1,2}EP?(\d{1,4})$|S\d{2}EP?(\d{2,4})"
     _part_re = r"(^PART[0-9ABI]{0,2}$|^CD[0-9]{0,2}$|^DVD[0-9]{0,2}$|^DISK[0-9]{0,2}$|^DISC[0-9]{0,2}$)"
     _roman_numerals = r"^(?=[MDCLXVI])M*(C[MD]|D?C{0,3})(X[CL]|L?X{0,3})(I[XV]|V?I{0,3})$"
-    _source_re = r"^BLURAY$|^HDTV$|^UHDTV$|^HDDVD$|^WEBRIP$|^DVDRIP$|^BDRIP$|^BLU$|^WEB$|^BD$|^HDRip$"
-    _effect_re = r"^REMUX$|^UHD$|^SDR$|^HDR\d*$|^DOLBY$|^DOVI$|^DV$|^3D$|^REPACK$"
+    _source_re = r"^BLURAY$|^HDTV$|^UHDTV$|^HDDVD$|^WEBRIP$|^DVDRIP$|^BDRIP$|^BLU$|^WEB$|^BD$|^HDRip$|^REMUX$|^UHD$"
+    _effect_re = r"^SDR$|^HDR\d*$|^DOLBY$|^DOVI$|^DV$|^3D$|^REPACK$|^HLG$|^HDR10(\+|Plus)$|^EDR$|^HQ$"
     _resources_type_re = r"%s|%s" % (_source_re, _effect_re)
-    _name_no_begin_re = r"^\[.+?]"
+    _name_no_begin_re = r"^[\[【].+?[\]】]"
     _name_no_chinese_re = r".*版|.*字幕"
     _name_se_words = ['共', '第', '季', '集', '话', '話', '期']
+    _name_movie_words = ['剧场版', '劇場版', '电影版', '電影版']
     _name_nostring_re = r"^PTS|^JADE|^AOD|^CHC|^[A-Z]{1,4}TV[\-0-9UVHDK]*" \
                         r"|HBO$|\s+HBO|\d{1,2}th|\d{1,2}bit|NETFLIX|AMAZON|IMAX|^3D|\s+3D|^BBC\s+|\s+BBC|BBC$|DISNEY\+?|XXX|\s+DC$" \
                         r"|[第\s共]+[0-9一二三四五六七八九十\-\s]+季" \
                         r"|[第\s共]+[0-9一二三四五六七八九十百零\-\s]+[集话話]" \
-                        r"|连载|日剧|美剧|电视剧|动画片|动漫|欧美|西德|日韩|超高清|高清|蓝光|翡翠台|梦幻天堂·龙网|★?\d*月?新番" \
-                        r"|最终季|合集|[多中国英葡法俄日韩德意西印泰台港粤双文语简繁体特效内封官译外挂]+字幕|版本|出品|台版|港版|\w+字幕组" \
+                        r"|连载|日剧|美剧|电视剧|动画片|动漫|欧美|西德|日韩|超高清|高清|无水印|下载|蓝光|翡翠台|梦幻天堂·龙网|★?\d*月?新番" \
+                        r"|最终季|合集|[多中国英葡法俄日韩德意西印泰台港粤双文语简繁体特效内封官译外挂]+字幕|版本|出品|台版|港版|\w+字幕组|\w+字幕社" \
                         r"|未删减版|UNCUT$|UNRATE$|WITH EXTRAS$|RERIP$|SUBBED$|PROPER$|REPACK$|SEASON$|EPISODE$|Complete$|Extended$|Extended Version$" \
                         r"|S\d{2}\s*-\s*S\d{2}|S\d{2}|\s+S\d{1,2}|EP?\d{2,4}\s*-\s*EP?\d{2,4}|EP?\d{2,4}|\s+EP?\d{1,4}" \
                         r"|CD[\s.]*[1-9]|DVD[\s.]*[1-9]|DISK[\s.]*[1-9]|DISC[\s.]*[1-9]" \
                         r"|[248]K|\d{3,4}[PIX]+" \
-                        r"|CD[\s.]*[1-9]|DVD[\s.]*[1-9]|DISK[\s.]*[1-9]|DISC[\s.]*[1-9]"
+                        r"|CD[\s.]*[1-9]|DVD[\s.]*[1-9]|DISK[\s.]*[1-9]|DISC[\s.]*[1-9]|\s+GB"
     _resources_pix_re = r"^[SBUHD]*(\d{3,4}[PI]+)|\d{3,4}X(\d{3,4})"
     _resources_pix_re2 = r"(^[248]+K)"
-    _video_encode_re = r"^[HX]26[45]$|^AVC$|^HEVC$|^VC\d?$|^MPEG\d?$|^Xvid$|^DivX$|^HDR\d*$"
-    _audio_encode_re = r"^DTS\d?$|^DTSHD$|^DTSHDMA$|^Atmos$|^TrueHD\d?$|^AC3$|^\dAudios?$|^DDP\d?$|^DD\d?$|^LPCM\d?$|^AAC\d?$|^FLAC\d?$|^HD\d?$|^MA\d?$"
+    _video_encode_re = r"^(H26[45])$|^(x26[45])$|^AVC$|^HEVC$|^VC\d?$|^MPEG\d?$|^Xvid$|^DivX$|^AV1$|^HDR\d*$|^AVS(\+|[23])$"
+    _audio_encode_re = r"^DTS\d?$|^DTSHD$|^DTSHDMA$|^Atmos$|^TrueHD\d?$|^AC3$|^\dAudios?$|^DDP\d?$|^DD\+\d?$|^DD\d?$|^LPCM\d?$|^AAC\d?$|^FLAC\d?$|^HD\d?$|^MA\d?$|^HR\d?$|^Opus\d?$|^Vorbis\d?$|^AV[3S]A$"
 
     def __init__(self, title: str, subtitle: str = None, isfile: bool = False):
+        """
+        初始化
+        :param title: 标题，文件为去掉了后缀
+        :param subtitle: 副标题
+        :param isfile: 是否是文件名
+        """
         super().__init__(title, subtitle, isfile)
         if not title:
             return
         original_title = title
         self._source = ""
         self._effect = []
+        self.web_source = None
+        self._index = 0
         # 判断是否纯数字命名
-        title_path = Path(title)
-        if title_path.suffix.lower() in settings.RMT_MEDIAEXT \
-                and title_path.stem.isdigit() \
-                and len(title_path.stem) < 5:
-            self.begin_episode = int(title_path.stem)
+        if isfile \
+                and title.isdigit() \
+                and len(title) < 5:
+            self.begin_episode = int(title)
             self.type = MediaType.TV
             return
+        # 全名为Season xx 及 Sxx 直接返回
+        season_full_res = re.search(r"^Season\s+(\d{1,3})$|^S(\d{1,3})$", title)
+        if season_full_res:
+            self.type = MediaType.TV
+            season = season_full_res.group(1)
+            if season:
+                self.begin_season = int(season)
+                self.total_season = 1
+            return
         # 去掉名称中第1个[]的内容
         title = re.sub(r'%s' % self._name_no_begin_re, "", title, count=1)
         # 把xxxx-xxxx年份换成前一个年份，常出现在季集上
@@ -75,9 +96,12 @@ class MetaVideo(MetaBase):
         # 拆分tokens
         tokens = Tokens(title)
         self.tokens = tokens
+        # 实例化StreamingPlatforms对象
+        streaming_platforms = StreamingPlatforms()
         # 解析名称、年份、季、集、资源类型、分辨率等
         token = tokens.get_next()
         while token:
+            self._index += 1  # 更新当前处理的token索引
             # Part
             self.__init_part(token)
             # 标题
@@ -98,6 +122,9 @@ class MetaVideo(MetaBase):
             # 资源类型
             if self._continue_flag:
                 self.__init_resource_type(token)
+            # 流媒体平台
+            if self._continue_flag:
+                self.__init_web_source(token, streaming_platforms)
             # 视频编码
             if self._continue_flag:
                 self.__init_video_encode(token)
@@ -113,6 +140,9 @@ class MetaVideo(MetaBase):
             self.resource_effect = " ".join(self._effect)
         if self._source:
             self.resource_type = self._source.strip()
+        # 添加流媒体平台
+        if self.web_source:
+            self.resource_type = f"{self.web_source} {self.resource_type}"
         # 提取原盘DIY
         if self.resource_type and "BluRay" in self.resource_type:
             if (self.subtitle and re.findall(r'D[Ii]Y', self.subtitle)) \
@@ -128,10 +158,47 @@ class MetaVideo(MetaBase):
         # 处理part
         if self.part and self.part.upper() == "PART":
             self.part = None
+        # 没有中文标题时，尝试中描述中获取中文名
+        if not self.cn_name and self.en_name and self.subtitle:
+            if self.__is_pinyin(self.en_name):
+                # 英文名是拼音
+                cn_name = self.__get_title_from_description(self.subtitle)
+                if cn_name and len(cn_name) == len(self.en_name.split()):
+                    # 中文名和拼音单词数相同，认为是中文名
+                    self.cn_name = cn_name
         # 制作组/字幕组
         self.resource_team = ReleaseGroupsMatcher().match(title=original_title) or None
+        # 自定义占位符
+        self.customization = CustomizationMatcher().match(title=original_title) or None
 
-    def __fix_name(self, name: str):
+    @staticmethod
+    def __get_title_from_description(description: str) -> Optional[str]:
+        """
+        从描述中提取标题
+        """
+        if not description:
+            return None
+        titles = re.split(r'[\s/|]+', description)
+        if StringUtils.is_chinese(titles[0]):
+            return titles[0]
+        return None
+
+    @staticmethod
+    def __is_pinyin(name_str: Optional[str]) -> bool:
+        """
+        判断是否拼音
+        """
+        if not name_str:
+            return False
+        for n in name_str.lower().split():
+            if not is_pinyin(n):
+                return False
+        return True
+
+    def __fix_name(self, name: Optional[str]):
+        """
+        去掉名字中不需要的干扰字符
+        """
         if not name:
             return name
         name = re.sub(r'%s' % self._name_nostring_re, '', name,
@@ -152,7 +219,10 @@ class MetaVideo(MetaBase):
                 name = None
         return name
 
-    def __init_name(self, token: str):
+    def __init_name(self, token: Optional[str]):
+        """
+        识别名称
+        """
         if not token:
             return
         # 回收标题
@@ -179,8 +249,9 @@ class MetaVideo(MetaBase):
             if not self.cn_name:
                 self.cn_name = token
             elif not self._stop_cnname_flag:
-                if not re.search("%s" % self._name_no_chinese_re, token, flags=re.IGNORECASE) \
-                        and not re.search("%s" % self._name_se_words, token, flags=re.IGNORECASE):
+                if re.search("%s" % self._name_movie_words, token, flags=re.IGNORECASE) \
+                        or (not re.search("%s" % self._name_no_chinese_re, token, flags=re.IGNORECASE)
+                            and not re.search("%s" % self._name_se_words, token, flags=re.IGNORECASE)):
                     self.cn_name = "%s %s" % (self.cn_name, token)
                 self._stop_cnname_flag = True
         else:
@@ -245,6 +316,9 @@ class MetaVideo(MetaBase):
                 self._last_token_type = "enname"
 
     def __init_part(self, token: str):
+        """
+        识别Part
+        """
         if not self.name:
             return
         if not self.year \
@@ -265,9 +339,12 @@ class MetaVideo(MetaBase):
                 self.tokens.get_next()
             self._last_token_type = "part"
             self._continue_flag = False
-            self._stop_name_flag = False
+            # self._stop_name_flag = False
 
     def __init_year(self, token: str):
+        """
+        识别年份
+        """
         if not self.name:
             return
         if not token.isdigit():
@@ -290,6 +367,9 @@ class MetaVideo(MetaBase):
         self._stop_name_flag = True
 
     def __init_resource_pix(self, token: str):
+        """
+        识别分辨率
+        """
         if not self.name:
             return
         re_res = re.findall(r"%s" % self._resources_pix_re, token, re.IGNORECASE)
@@ -326,6 +406,9 @@ class MetaVideo(MetaBase):
                     self.resource_pix = re_res.group(1).lower()
 
     def __init_season(self, token: str):
+        """
+        识别季
+        """
         re_res = re.findall(r"%s" % self._season_re, token, re.IGNORECASE)
         if re_res:
             self._last_token_type = "season"
@@ -375,6 +458,9 @@ class MetaVideo(MetaBase):
             self.begin_season = 1
 
     def __init_episode(self, token: str):
+        """
+        识别集
+        """
         re_res = re.findall(r"%s" % self._episode_re, token, re.IGNORECASE)
         if re_res:
             self._last_token_type = "episode"
@@ -445,8 +531,42 @@ class MetaVideo(MetaBase):
             self._last_token_type = "EPISODE"
 
     def __init_resource_type(self, token):
+        """
+        识别资源类型
+        """
         if not self.name:
             return
+        if token.upper() == "DL" \
+                and self._last_token_type == "source" \
+                and self._last_token == "WEB":
+            self._source = "WEB-DL"
+            self._continue_flag = False
+            return
+        elif token.upper() == "RAY" \
+                and self._last_token_type == "source" \
+                and self._last_token == "BLU":
+            # UHD BluRay组合
+            if self._source == "UHD":
+                self._source = "UHD BluRay"
+            else:
+                self._source = "BluRay"
+            self._continue_flag = False
+            return
+        elif token.upper() == "WEBDL":
+            self._source = "WEB-DL"
+            self._continue_flag = False
+            return
+            # UHD REMUX组合
+        if token.upper() == "REMUX" \
+                and self._source == "BluRay":
+            self._source = "BluRay REMUX"
+            self._continue_flag = False
+            return
+        elif token.upper() == "BLURAY" \
+                and self._source == "UHD":
+            self._source = "UHD BluRay"
+            self._continue_flag = False
+            return
         source_res = re.search(r"(%s)" % self._source_re, token, re.IGNORECASE)
         if source_res:
             self._last_token_type = "source"
@@ -456,22 +576,6 @@ class MetaVideo(MetaBase):
                 self._source = source_res.group(1)
                 self._last_token = self._source.upper()
             return
-        elif token.upper() == "DL" \
-                and self._last_token_type == "source" \
-                and self._last_token == "WEB":
-            self._source = "WEB-DL"
-            self._continue_flag = False
-            return
-        elif token.upper() == "RAY" \
-                and self._last_token_type == "source" \
-                and self._last_token == "BLU":
-            self._source = "BluRay"
-            self._continue_flag = False
-            return
-        elif token.upper() == "WEBDL":
-            self._source = "WEB-DL"
-            self._continue_flag = False
-            return
         effect_res = re.search(r"(%s)" % self._effect_re, token, re.IGNORECASE)
         if effect_res:
             self._last_token_type = "effect"
@@ -482,7 +586,61 @@ class MetaVideo(MetaBase):
                 self._effect.append(effect)
             self._last_token = effect.upper()
 
+    def __init_web_source(self, token: str, streaming_platforms: StreamingPlatforms):
+        """
+        识别流媒体平台
+        """
+        if not self.name:
+            return
+
+        platform_name = None
+        query_range = 1
+
+        prev_token = None
+        prev_idx = self._index - 2
+        if 0 <= prev_idx < len(self.tokens.tokens):
+            prev_token = self.tokens.tokens[prev_idx]
+
+        next_token = self.tokens.peek()
+
+        if streaming_platforms.is_streaming_platform(token):
+            platform_name = streaming_platforms.get_streaming_platform_name(token)
+        else:
+            for adjacent_token, is_next in [(prev_token, False), (next_token, True)]:
+                if not adjacent_token or platform_name:
+                    continue
+
+                for separator in [" ", "-"]:
+                    if is_next:
+                        combined_token = f"{token}{separator}{adjacent_token}"
+                    else:
+                        combined_token = f"{adjacent_token}{separator}{token}"
+
+                    if streaming_platforms.is_streaming_platform(combined_token):
+                        platform_name = streaming_platforms.get_streaming_platform_name(combined_token)
+                        query_range = 2
+                        if is_next:
+                            self.tokens.get_next()
+                        break
+
+        if not platform_name:
+            return
+
+        web_tokens = ["WEB", "DL", "WEBDL", "WEBRIP"]
+        match_start_idx = self._index - query_range
+        match_end_idx = self._index - 1
+        start_index = max(0, match_start_idx - query_range)
+        end_index = min(len(self.tokens.tokens), match_end_idx + 1 + query_range)
+        tokens_to_check = self.tokens.tokens[start_index:end_index]
+
+        if any(tok and tok.upper() in web_tokens for tok in tokens_to_check):
+            self.web_source = platform_name
+            self._continue_flag = False
+
     def __init_video_encode(self, token: str):
+        """
+        识别视频编码
+        """
         if not self.name:
             return
         if not self.year \
@@ -497,7 +655,12 @@ class MetaVideo(MetaBase):
             self._stop_name_flag = True
             self._last_token_type = "videoencode"
             if not self.video_encode:
-                self.video_encode = re_res.group(1).upper()
+                if re_res.group(2):
+                    self.video_encode = re_res.group(2).upper()
+                elif re_res.group(3):
+                    self.video_encode = re_res.group(3).lower()
+                else:
+                    self.video_encode = re_res.group(1).upper()
                 self._last_token = self.video_encode
             elif self.video_encode == "10bit":
                 self.video_encode = f"{re_res.group(1).upper()} 10bit"
@@ -523,6 +686,9 @@ class MetaVideo(MetaBase):
                 self.video_encode = f"{self.video_encode} 10bit"
 
     def __init_audio_encode(self, token: str):
+        """
+        识别音频编码
+        """
         if not self.name:
             return
         if not self.year \

app/core/meta/releasegroup.py

@@ -15,32 +15,32 @@ class ReleaseGroupsMatcher(metaclass=Singleton):
         "0ff": ['FF(?:(?:A|WE)B|CD|E(?:DU|B)|TV)'],
         "1pt": [],
         "52pt": [],
-        "audiences": ['Audies', 'AD(?:Audio|E(?:|book)|Music|Web)'],
+        "audiences": ['Audies', 'AD(?:Audio|E(?:book|)|Music|Web)'],
         "azusa": [],
         "beitai": ['BeiTai'],
         "btschool": ['Bts(?:CHOOL|HD|PAD|TV)', 'Zone'],
         "carpt": ['CarPT'],
-        "chdbits": ['CHD(?:|Bits|PAD|(?:|HK)TV|WEB)', 'StBOX', 'OneHD', 'Lee', 'xiaopie'],
+        "chdbits": ['CHD(?:Bits|PAD|(?:|HK)TV|WEB|)', 'StBOX', 'OneHD', 'Lee', 'xiaopie'],
         "discfan": [],
         "dragonhd": [],
         "eastgame": ['(?:(?:iNT|(?:HALFC|Mini(?:S|H|FH)D))-|)TLF'],
         "filelist": [],
         "gainbound": ['(?:DG|GBWE)B'],
-        "hares": ['Hares(?:|(?:M|T)V|Web)'],
+        "hares": ['Hares(?:(?:M|T)V|Web|)'],
         "hd4fans": [],
         "hdarea": ['HDA(?:pad|rea|TV)', 'EPiC'],
         "hdatmos": [],
         "hdbd": [],
-        "hdchina": ['HDC(?:|hina|TV)', 'k9611', 'tudou', 'iHD'],
+        "hdchina": ['HDC(?:hina|TV|)', 'k9611', 'tudou', 'iHD'],
         "hddolby": ['D(?:ream|BTV)', '(?:HD|QHstudI)o'],
-        "hdfans": ['beAst(?:|TV)'],
-        "hdhome": ['HDH(?:|ome|Pad|TV|WEB)'],
-        "hdpt": ['HDPT(?:|Web)'],
-        "hdsky": ['HDS(?:|ky|TV|Pad|WEB)', 'AQLJ'],
+        "hdfans": ['beAst(?:TV|)'],
+        "hdhome": ['HDH(?:ome|Pad|TV|WEB|)'],
+        "hdpt": ['HDPT(?:Web|)'],
+        "hdsky": ['HDS(?:ky|TV|Pad|WEB|)', 'AQLJ'],
         "hdtime": [],
         "HDU": [],
         "hdvideo": [],
-        "hdzone": ['HDZ(?:|one)'],
+        "hdzone": ['HDZ(?:one|)'],
         "hhanclub": ['HHWEB'],
         "hitpt": [],
         "htpt": ['HTPT'],
@@ -48,34 +48,39 @@ class ReleaseGroupsMatcher(metaclass=Singleton):
         "joyhd": [],
         "keepfrds": ['FRDS', 'Yumi', 'cXcY'],
         "lemonhd": ['L(?:eague(?:(?:C|H)D|(?:M|T)V|NF|WEB)|HD)', 'i18n', 'CiNT'],
-        "mteam": ['MTeam(?:|TV)', 'MPAD'],
+        "mteam": ['MTeam(?:TV|)', 'MPAD'],
         "nanyangpt": [],
         "nicept": [],
         "oshen": [],
         "ourbits": ['Our(?:Bits|TV)', 'FLTTH', 'Ao', 'PbK', 'MGs', 'iLove(?:HD|TV)'],
         "piggo": ['PiGo(?:NF|(?:H|WE)B)'],
         "ptchina": [],
-        "pterclub": ['PTer(?:|DIY|Game|(?:M|T)V|WEB)'],
-        "pthome": ['PTH(?:|Audio|eBook|music|ome|tv|WEB)'],
+        "pterclub": ['PTer(?:DIY|Game|(?:M|T)V|WEB|)'],
+        "pthome": ['PTH(?:Audio|eBook|music|ome|tv|WEB|)'],
         "ptmsg": [],
         "ptsbao": ['PTsbao', 'OPS', 'F(?:Fans(?:AIeNcE|BD|D(?:VD|IY)|TV|WEB)|HDMv)', 'SGXT'],
         "pttime": [],
         "putao": ['PuTao'],
         "soulvoice": [],
-        "springsunday": ['CMCT(?:|V)'],
-        "sharkpt": ['Shark(?:|WEB|DIY|TV|MV)'],
+        "springsunday": ['CMCT(?:V|)'],
+        "sharkpt": ['Shark(?:WEB|DIY|TV|MV|)'],
         "tccf": [],
         "tjupt": ['TJUPT'],
         "totheglory": ['TTG', 'WiKi', 'NGB', 'DoA', '(?:ARi|ExRE)N'],
         "U2": [],
         "ultrahd": [],
-        "others": ['B(?:MDru|eyondHD|TN)', 'C(?:fandora|trlhd|MRG)', 'DON', 'EVO', 'FLUX', 'HONE(?:|yG)',
-                   'N(?:oGroup|T(?:b|G))', 'PandaMoon', 'SMURF', 'T(?:EPES|aengoo|rollHD )'],
-        "anime": ['ANi', 'HYSUB', 'KTXP', 'LoliHouse', 'MCE', 'Nekomoe kissaten', '(?:Lilith|NC)-Raws', '织梦字幕组']
+        "others": ['B(?:MDru|eyondHD|TN)', 'C(?:fandora|trlhd|MRG)', 'DON', 'EVO', 'FLUX', 'HONE(?:yG|)',
+                   'N(?:oGroup|T(?:b|G))', 'PandaMoon', 'SMURF', 'T(?:EPES|aengoo|rollHD )',],
+        "anime": ['ANi', 'HYSUB', 'KTXP', 'LoliHouse', 'MCE', 'Nekomoe kissaten', 'SweetSub', 'MingY',
+                  '(?:Lilith|NC)-Raws', '织梦字幕组', '枫叶字幕组', '猎户手抄部', '喵萌奶茶屋', '漫猫字幕社',
+                  '霜庭云花Sub', '北宇治字幕组', '氢气烤肉架', '云歌字幕组', '萌樱字幕组', '极影字幕社',
+                  '悠哈璃羽字幕社',
+                  '❀拨雪寻春❀', '沸羊羊(?:制作|字幕组)', '(?:桜|樱)都字幕组'],
+        "forge": ['FROG(?:E|Web|)'],
+        "ubits": ['UB(?:its|WEB|TV)'],
     }
 
     def __init__(self):
-        self.systemconfig = SystemConfigOper()
         release_groups = []
         for site_groups in self.RELEASE_GROUPS.values():
             for release_group in site_groups:
@@ -92,14 +97,16 @@ class ReleaseGroupsMatcher(metaclass=Singleton):
             return ""
         if not groups:
             # 自定义组
-            custom_release_groups = self.systemconfig.get(SystemConfigKey.CustomReleaseGroups)
+            custom_release_groups = SystemConfigOper().get(SystemConfigKey.CustomReleaseGroups)
+            if isinstance(custom_release_groups, list):
+                custom_release_groups = list(filter(None, custom_release_groups))
             if custom_release_groups:
                 custom_release_groups_str = '|'.join(custom_release_groups)
                 groups = f"{self.__release_groups}|{custom_release_groups_str}"
             else:
                 groups = self.__release_groups
         title = f"{title} "
-        groups_re = re.compile(r"(?<=[-@\[￡【&])(?:%s)(?=[@.\s\]\[】&])" % groups, re.I)
+        groups_re = re.compile(r"(?<=[-@\[￡【&])(?:%s)(?=[@.\s\S\]\[】&])" % groups, re.I)
         # 处理一个制作组识别多次的情况，保留顺序
         unique_groups = []
         for item in re.findall(groups_re, title):

app/core/meta/streamingplatform.py

@@ -0,0 +1,315 @@
+from typing import Optional, List, Tuple
+
+from app.utils.singleton import Singleton
+
+
+class StreamingPlatforms(metaclass=Singleton):
+    """
+    流媒体平台简称与全称。
+    """
+    STREAMING_PLATFORMS: List[Tuple[str, str]] = [
+        ("AMZN", "Amazon"),
+        ("NF", "Netflix"),
+        ("ATVP", "Apple TV+"),
+        ("iT", "iTunes"),
+        ("DSNP", "Disney+"),
+        ("HS", "Hotstar"),
+        ("APPS", "Disney+ MENA"),
+        ("PMTP", "Paramount+"),
+        ("HMAX", "Max"),
+        ("", "Max"),
+        ("HULU", "Hulu Networks"),
+        ("MA", "Movies Anywhere"),
+        ("BCORE", "Bravia Core"),
+        ("MS", "Microsoft Store"),
+        ("SHO", "Showtime"),
+        ("STAN", "Stan"),
+        ("PCOK", "Peacock"),
+        ("SKST", "SkyShowtime"),
+        ("NOW", "Now"),
+        ("FXTL", "Foxtel Now"),
+        ("BNGE", "Binge"),
+        ("CRKL", "Crackle"),
+        ("RKTN", "Rakuten TV"),
+        ("ALL4", "Channel 4"),
+        ("AS", "Adult Swim"),
+        ("BRTB", "Brtb TV"),
+        ("CNLP", "Canal+"),
+        ("CRIT", "Criterion Channel"),
+        ("DSCP", "Discovery+"),
+        ("FOOD", "Food Network"),
+        ("MUBI", "Mubi"),
+        ("PLAY", "Google Play"),
+        ("YT", "YouTube"),
+        ("", "friDay"),
+        ("", "KKTV"),
+        ("", "ofiii"),
+        ("", "LiTV"),
+        ("", "MyVideo"),
+        ("Hami", "Hami Video"),
+        ("HamiVideo", "Hami Video"),
+        ("MW", "meWATCH"),
+        ("CATCHPLAY", "CATCHPLAY+"),
+        ("CPP", "CATCHPLAY+"),
+        ("LINETV", "LINE TV"),
+        ("VIU", "Viu"),
+        ("IQ", ""),
+        ("", "WeTV"),
+        ("ABMA", "Abema"),
+        ("ADN", ""),
+        ("AT-X", ""),
+        ("Baha", ""),
+        ("BG", "B-Global"),
+        ("CR", "Crunchyroll"),
+        ("", "DMM"),
+        ("FOD", ""),
+        ("FUNi", "Funimation"),
+        ("HIDI", "HIDIVE"),
+        ("UNXT", "U-NEXT"),
+        ("FAA", "Filmarchiv Austria"),
+        ("CC", "Comedy Central"),
+        ("iP", "BBC iPlayer"),
+        ("9NOW", "9Now"),
+        ("ABC", ""),
+        ("", "AMC"),
+        ("", "ZEE5"),
+        ("", "WAVO"),
+        ("SHAHID", "Shahid"),
+        ("Flixole", "FlixOlé"),
+        ("TOU", "Ici TOU.TV"),
+        ("ROKU", "Roku"),
+        ("KNPY", "Kanopy"),
+        ("SNXT", "Sun NXT"),
+        ("CUR", "Curiosity Stream"),
+        ("MY5", "Channel 5"),
+        ("AHA", "aha"),
+        ("WOWP", "WOW Presents Plus"),
+        ("JC", "JioCinema"),
+        ("", "Dekkoo"),
+        ("FILMZIE", "Filmzie"),
+        ("HoiChoi", "Hoichoi"),
+        ("VIKI", "Rakuten Viki"),
+        ("SF", "SF Anytime"),
+        ("PLEX", "Plex"),
+        ("SHDR", "Shudder"),
+        ("CRAV", "Crave"),
+        ("CPE", "Cineplex Entertainment"),
+        ("JF HC", ""),
+        ("JF", ""),
+        ("JFFP", ""),
+        ("VIAP", "Viaplay"),
+        ("TUBI", "TubiTV"),
+        ("", "PBS"),
+        ("PBSK", "PBS KIDS"),
+        ("LGP", "Lionsgate Play"),
+        ("", "CTV"),
+        ("", "Cineverse"),
+        ("LN", "Love Nature"),
+        ("MP", "Movistar Plus+"),
+        ("RUNTIME", "Runtime"),
+        ("STZ", "STARZ"),
+        ("FUBO", "fuboTV"),
+        ("TENK", "Tënk"),
+        ("KNOW", "Knowledge Network"),
+        ("TVO", "tvo"),
+        ("", "OVID"),
+        ("CBC", "CBC Gem"),
+        ("FANDOR", "fandor"),
+        ("CW", "The CW"),
+        ("KNPY", "Kanopy"),
+        ("FREE", "Freeform"),
+        ("AE", "A&E"),
+        ("LIFE", "Lifetime"),
+        ("WWEN", "WWE Network"),
+        ("CMAX", "Cinemax"),
+        ("HLMK", "Hallmark"),
+        ("BYU", "BYUtv"),
+        ("", "ViX"),
+        ("VICE", "Viceland"),
+        ("", "TVING"),
+        ("USAN", "USA Network"),
+        ("FOX", ""),
+        ("", "TCM"),
+        ("BRAV", "BravoTV"),
+        ("", "TNT"),
+        ("", "ZDF"),
+        ("", "IndieFlix"),
+        ("", "TLC"),
+        ("", "HGTV"),
+        ("ANPL", "Animal Planet"),
+        ("TRVL", "Travel Channel"),
+        ("", "VH1"),
+        ("SAINA", "Saina Play"),
+        ("SP", "Saina Play"),
+        ("OXGN", "Oxygen"),
+        ("PSN", "PlayStation Network"),
+        ("PMNT", "Paramount Network"),
+        ("FAWESOME", "Fawesome"),
+        ("KLASSIKI", "Klassiki"),
+        ("STRP", "Star+"),
+        ("NATG", "National Geographic"),
+        ("REVEEL", "Reveel"),
+        ("FYI", "FYI Network"),
+        ("WatchiT", "WATCH IT"),
+        ("ITVX", "ITV"),
+        ("GAIA", "Gaia"),
+        ("", "FlixLatino"),
+        ("CNNP", "CNN+"),
+        ("TROMA", "Troma"),
+        ("IVI", "Ivi"),
+        ("9NOW", "9Now"),
+        ("A3P", "Atresplayer"),
+        ("7PLUS", "7plus"),
+        ("", "SBS"),
+        ("TEN", "10Play"),
+        ("AUBC", ""),
+        ("DSNY", "Disney Networks"),
+        ("OSN", "OSN+"),
+        ("SVT", "Sveriges Television"),
+        ("LACINETEK", "LaCinetek"),
+        ("", "Maxdome"),
+        ("RTL", "RTL+"),
+        ("ARTE", "Arte"),
+        ("JOYN", "Joyn"),
+        ("TV2", "TV 2"),
+        ("3SAT", "3sat"),
+        ("FILMINGO", "filmingo"),
+        ("", "WOW"),
+        ("OKKO", "Okko"),
+        ("", "Go3"),
+        ("ARGP", "Argo"),
+        ("VOYO", "Voyo"),
+        ("VMAX", "vivamax"),
+        ("FILMIN", "Filmin"),
+        ("", "Mitele"),
+        ("MY5", "Channel 5"),
+        ("", "ARD"),
+        ("BK", "Bentkey"),
+        ("BOOM", "Boomerang"),
+        ("", "CBS"),
+        ("CLBI", "Club illico"),
+        ("CMOR", "C More"),
+        ("CMT", ""),
+        ("", "CNBC"),
+        ("COOK", "Cooking Channel"),
+        ("CWS", "CW Seed"),
+        ("DCU", "DC Universe"),
+        ("DDY", "Digiturk Dilediğin Yerde"),
+        ("DEST", "Destination America"),
+        ("DISC", "Discovery Channel"),
+        ("DW", "DailyWire+"),
+        ("DLWP", "DailyWire+"),
+        ("DPLY", "dplay"),
+        ("DRPO", "Dropout"),
+        ("EPIX", "EPIX MGM+"),
+        ("ESQ", "Esquire"),
+        ("ETV", "E!"),
+        ("FBWatch", "Facebook Watch"),
+        ("FPT", "FPT Play"),
+        ("FTV", "France.tv"),
+        ("GLOB", "GloboSat Play"),
+        ("GLBO", "Globoplay"),
+        ("GO90", "go90"),
+        ("HIST", "History Channel"),
+        ("HPLAY", "Hungama Play"),
+        ("KS", "Kaleidescape"),
+        ("", "MBC"),
+        ("MMAX", "ManoramaMAX"),
+        ("MNBC", "MSNBC"),
+        ("MTOD", "Motor Trend OnDemand"),
+        ("NBC", ""),
+        ("NBLA", "Nebula"),
+        ("NICK", "Nickelodeon"),
+        ("ODK", "OnDemandKorea"),
+        ("POGO", "PokerGO"),
+        ("PUHU", "puhutv"),
+        ("QIBI", "Quibi"),
+        ("RTE", "RTÉ"),
+        ("SESO", "Seeso"),
+        ("SPIK", "Spike"),
+        ("SS", "Simply South"),
+        ("SYFY", "SyFy"),
+        ("TIMV", "TIMvision"),
+        ("TK", "Tentkotta"),
+        ("", "TV4"),
+        ("TVL", "TV Land"),
+        ("", "TVNZ"),
+        ("", "UKTV"),
+        ("VLCT", "Discovery Velocity"),
+        ("VMEO", "Vimeo"),
+        ("VRV", "VRV Defunct"),
+        ("WTCH", "Watcha"),
+        ("", "NowPlayer"),
+        ("HuluJP", "Hulu Networks"),
+        ("Gaga", "GagaOOLala"),
+        ("MyTVS", "MyTVSuper"),
+        ("", "BBC"),
+        ("CC", "Comedy Central"),
+        ("NowE", "Now E"),
+        ("WAVVE", "Wavve"),
+        ("SE", ""),
+        ("", "BritBox"),
+        ("AOD", "Anime on Demand"),
+        ("AF", ""),
+        ("BCH", "Bandai Channel"),
+        ("VMJ", "VideoMarket"),
+        ("LFTL", "Laftel"),
+        ("WAKA", "Wakanim"),
+        ("WAKANIM", "Wakanim"),
+        ("AO", "AnimeOnegai"),
+        ("", "Lemino"),
+        ("VIDIO", "Vidio"),
+        ("TVER", "TVer"),
+        ("", "MBS"),
+        ("LFTLNET", "Laftel"),
+        ("JONU", "Jonu Play"),
+        ("PlutoTV", "Pluto TV"),
+        ("AbemaTV", "Abema"),
+        ("", "dTV"),
+        ("NYMEY", "Nymey"),
+        ("SMNS", "SAMANSA"),
+        ("CTHP", "CATCHPLAY+"),
+        ("HBOGO", "HBO GO"),
+        ("HBO", "HBO"),
+        ("FPTP", "FPT Play"),
+        ("", "LOCIPO"),
+        ("DANT", "DANET"),
+        ("OV", "OceanVeil"),
+    ]
+
+    def __init__(self):
+        """初始化流媒体平台匹配器"""
+        self._lookup_cache = {}
+        self._build_cache()
+
+    def _build_cache(self) -> None:
+        """
+        构建查询缓存。
+        """
+        self._lookup_cache.clear()
+        for short_name, full_name in self.STREAMING_PLATFORMS:
+            canonical_name = full_name or short_name
+            if not canonical_name:
+                continue
+
+            aliases = {short_name, full_name}
+            for alias in aliases:
+                if alias:
+                    self._lookup_cache[alias.upper()] = canonical_name
+
+    def get_streaming_platform_name(self, platform_code: str) -> Optional[str]:
+        """
+        根据流媒体平台简称或全称获取标准名称。
+        """
+        if platform_code is None:
+            return None
+        return self._lookup_cache.get(platform_code.upper())
+
+    def is_streaming_platform(self, name: str) -> bool:
+        """
+        判断给定的字符串是否为已知的流媒体平台代码或名称。
+        """
+        if name is None:
+            return False
+        return name.upper() in self._lookup_cache
+

app/core/meta/words.py

@@ -14,7 +14,7 @@ class WordsMatcher(metaclass=Singleton):
     def __init__(self):
         self.systemconfig = SystemConfigOper()
 
-    def prepare(self, title: str) -> Tuple[str, List[str]]:
+    def prepare(self, title: str, custom_words: List[str] = None) -> Tuple[str, List[str]]:
         """
         预处理标题，支持三种格式
         1：屏蔽词
@@ -23,9 +23,9 @@ class WordsMatcher(metaclass=Singleton):
         """
         appley_words = []
         # 读取自定义识别词
-        words: List[str] = self.systemconfig.get(SystemConfigKey.CustomIdentifiers) or []
+        words: List[str] = custom_words or self.systemconfig.get(SystemConfigKey.CustomIdentifiers) or []
         for word in words:
-            if not word:
+            if not word or word.startswith("#"):
                 continue
             try:
                 if word.count(" => ") and word.count(" && ") and word.count(" >> ") and word.count(" <> "):
@@ -53,18 +53,18 @@ class WordsMatcher(metaclass=Singleton):
                     strings = word.split(" <> ")
                     offsets = strings[1].split(" >> ")
                     strings[1] = offsets[0]
-                    title, message, state = self.__episode_offset(title, strings[0], strings[1],
-                                                                  offsets[1])
+                    title, message, state = self.__episode_offset(title, strings[0], strings[1], offsets[1])
                 else:
                     # 屏蔽词
+                    if not word.strip():
+                        continue
                     title, message, state = self.__replace_regex(title, word, "")
 
                 if state:
                     appley_words.append(word)
-                else:
-                    logger.debug(f"自定义识别词替换失败：{message}")
+
             except Exception as err:
-                print(str(err))
+                logger.warn(f"自定义识别词 {word} 预处理标题失败：{str(err)} - 标题：{title}")
 
         return title, appley_words
 
@@ -79,7 +79,7 @@ class WordsMatcher(metaclass=Singleton):
             else:
                 return re.sub(r'%s' % replaced, r'%s' % replace, title), "", True
         except Exception as err:
-            print(str(err))
+            logger.warn(f"自定义识别词正则替换失败：{str(err)} - 标题：{title}，被替换词：{replaced}，替换词：{replace}")
             return title, str(err), False
 
     @staticmethod
@@ -131,5 +131,5 @@ class WordsMatcher(metaclass=Singleton):
                 title = re.sub(episode_offset_re, r'%s' % episode_num[1], title)
             return title, "", True
         except Exception as err:
-            print(str(err))
+            logger.warn(f"自定义识别词集数偏移失败：{str(err)} - 标题：{title}，前定位词：{front}，后定位词：{back}，偏移量：{offset}")
             return title, str(err), False

app/core/metainfo.py

@@ -1,26 +1,34 @@
 from pathlib import Path
+from typing import Tuple, List, Optional
 
 import regex as re
 
 from app.core.config import settings
 from app.core.meta import MetaAnime, MetaVideo, MetaBase
 from app.core.meta.words import WordsMatcher
+from app.log import logger
+from app.schemas.types import MediaType
 
 
-def MetaInfo(title: str, subtitle: str = None) -> MetaBase:
+def MetaInfo(title: str, subtitle: Optional[str] = None, custom_words: List[str] = None) -> MetaBase:
     """
     根据标题和副标题识别元数据
     :param title: 标题、种子名、文件名
     :param subtitle: 副标题、描述
+    :param custom_words: 自定义识别词列表
     :return: MetaAnime、MetaVideo
     """
     # 原标题
     org_title = title
     # 预处理标题
-    title, apply_words = WordsMatcher().prepare(title)
+    title, apply_words = WordsMatcher().prepare(title, custom_words=custom_words)
+    # 获取标题中媒体信息
+    title, metainfo = find_metainfo(title)
     # 判断是否处理文件
     if title and Path(title).suffix.lower() in settings.RMT_MEDIAEXT:
         isfile = True
+        # 去掉后缀
+        title = Path(title).stem
     else:
         isfile = False
     # 识别
@@ -29,7 +37,28 @@ def MetaInfo(title: str, subtitle: str = None) -> MetaBase:
     meta.title = org_title
     #  记录使用的识别词
     meta.apply_words = apply_words or []
-
+    # 修正媒体信息
+    if metainfo.get('tmdbid'):
+        try:
+            meta.tmdbid = int(metainfo['tmdbid'])
+        except ValueError as _:
+            logger.warn("tmdbid 必须是数字")
+    if metainfo.get('doubanid'):
+        meta.doubanid = metainfo['doubanid']
+    if metainfo.get('type'):
+        meta.type = metainfo['type']
+    if metainfo.get('begin_season'):
+        meta.begin_season = metainfo['begin_season']
+    if metainfo.get('end_season'):
+        meta.end_season = metainfo['end_season']
+    if metainfo.get('total_season'):
+        meta.total_season = metainfo['total_season']
+    if metainfo.get('begin_episode'):
+        meta.begin_episode = metainfo['begin_episode']
+    if metainfo.get('end_episode'):
+        meta.end_episode = metainfo['end_episode']
+    if metainfo.get('total_episode'):
+        meta.total_episode = metainfo['total_episode']
     return meta
 
 
@@ -38,12 +67,16 @@ def MetaInfoPath(path: Path) -> MetaBase:
     根据路径识别元数据
     :param path: 路径
     """
+    # 文件元数据，不包含后缀
+    file_meta = MetaInfo(title=path.name)
     # 上级目录元数据
     dir_meta = MetaInfo(title=path.parent.name)
-    # 文件元数据，不包含后缀
-    file_meta = MetaInfo(title=path.stem)
     # 合并元数据
     file_meta.merge(dir_meta)
+    # 上上级目录元数据
+    root_meta = MetaInfo(title=path.parent.parent.name)
+    # 合并元数据
+    file_meta.merge(root_meta)
     return file_meta
 
 
@@ -59,9 +92,108 @@ def is_anime(name: str) -> bool:
         return True
     if re.search(r'\s+-\s+[\dv]{1,4}\s+', name, re.IGNORECASE):
         return True
-    if re.search(r"S\d{2}\s*-\s*S\d{2}|S\d{2}|\s+S\d{1,2}|EP?\d{2,4}\s*-\s*EP?\d{2,4}|EP?\d{2,4}|\s+EP?\d{1,4}", name,
+    if re.search(r"S\d{2}\s*-\s*S\d{2}|S\d{2}|\s+S\d{1,2}|EP?\d{2,4}\s*-\s*EP?\d{2,4}|EP?\d{2,4}|\s+EP?\d{1,4}",
+                 name,
                  re.IGNORECASE):
         return False
     if re.search(r'\[[+0-9XVPI-]+]\s*\[', name, re.IGNORECASE):
         return True
     return False
+
+
+def find_metainfo(title: str) -> Tuple[str, dict]:
+    """
+    从标题中提取媒体信息
+    """
+    metainfo = {
+        'tmdbid': None,
+        'doubanid': None,
+        'type': None,
+        'begin_season': None,
+        'end_season': None,
+        'total_season': None,
+        'begin_episode': None,
+        'end_episode': None,
+        'total_episode': None,
+    }
+    if not title:
+        return title, metainfo
+    # 从标题中提取媒体信息 格式为{[tmdbid=xxx;type=xxx;s=xxx;e=xxx]}
+    results = re.findall(r'(?<={\[)[\W\w]+(?=]})', title)
+    if results:
+        for result in results:
+            # 查找tmdbid信息
+            tmdbid = re.findall(r'(?<=tmdbid=)\d+', result)
+            if tmdbid and tmdbid[0].isdigit():
+                metainfo['tmdbid'] = tmdbid[0]
+            # 查找豆瓣id信息
+            doubanid = re.findall(r'(?<=doubanid=)\d+', result)
+            if doubanid and doubanid[0].isdigit():
+                metainfo['doubanid'] = doubanid[0]
+            # 查找媒体类型
+            mtype = re.findall(r'(?<=type=)\w+', result)
+            if mtype:
+                if mtype[0] == "movies":
+                    metainfo['type'] = MediaType.MOVIE
+                elif mtype[0] == "tv":
+                    metainfo['type'] = MediaType.TV
+            # 查找季信息
+            begin_season = re.findall(r'(?<=s=)\d+', result)
+            if begin_season and begin_season[0].isdigit():
+                metainfo['begin_season'] = int(begin_season[0])
+            end_season = re.findall(r'(?<=s=\d+-)\d+', result)
+            if end_season and end_season[0].isdigit():
+                metainfo['end_season'] = int(end_season[0])
+            # 查找集信息
+            begin_episode = re.findall(r'(?<=e=)\d+', result)
+            if begin_episode and begin_episode[0].isdigit():
+                metainfo['begin_episode'] = int(begin_episode[0])
+            end_episode = re.findall(r'(?<=e=\d+-)\d+', result)
+            if end_episode and end_episode[0].isdigit():
+                metainfo['end_episode'] = int(end_episode[0])
+            # 去除title中该部分
+            if tmdbid or mtype or begin_season or end_season or begin_episode or end_episode:
+                title = title.replace(f"{{[{result}]}}", '')
+    
+    # 支持Emby格式的ID标签
+    # 1. [tmdbid=xxxx] 或 [tmdbid-xxxx] 格式
+    tmdb_match = re.search(r'\[tmdbid[=\-](\d+)\]', title)
+    if tmdb_match:
+        metainfo['tmdbid'] = tmdb_match.group(1)
+        title = re.sub(r'\[tmdbid[=\-](\d+)\]', '', title).strip()
+    
+    # 2. [tmdb=xxxx] 或 [tmdb-xxxx] 格式
+    if not metainfo['tmdbid']:
+        tmdb_match = re.search(r'\[tmdb[=\-](\d+)\]', title)
+        if tmdb_match:
+            metainfo['tmdbid'] = tmdb_match.group(1)
+            title = re.sub(r'\[tmdb[=\-](\d+)\]', '', title).strip()
+    
+    # 3. {tmdbid=xxxx} 或 {tmdbid-xxxx} 格式
+    if not metainfo['tmdbid']:
+        tmdb_match = re.search(r'\{tmdbid[=\-](\d+)\}', title)
+        if tmdb_match:
+            metainfo['tmdbid'] = tmdb_match.group(1)
+            title = re.sub(r'\{tmdbid[=\-](\d+)\}', '', title).strip()
+    
+    # 4. {tmdb=xxxx} 或 {tmdb-xxxx} 格式
+    if not metainfo['tmdbid']:
+        tmdb_match = re.search(r'\{tmdb[=\-](\d+)\}', title)
+        if tmdb_match:
+            metainfo['tmdbid'] = tmdb_match.group(1)
+            title = re.sub(r'\{tmdb[=\-](\d+)\}', '', title).strip()
+    
+    # 计算季集总数
+    if metainfo.get('begin_season') and metainfo.get('end_season'):
+        if metainfo['begin_season'] > metainfo['end_season']:
+            metainfo['begin_season'], metainfo['end_season'] = metainfo['end_season'], metainfo['begin_season']
+        metainfo['total_season'] = metainfo['end_season'] - metainfo['begin_season'] + 1
+    elif metainfo.get('begin_season') and not metainfo.get('end_season'):
+        metainfo['total_season'] = 1
+    if metainfo.get('begin_episode') and metainfo.get('end_episode'):
+        if metainfo['begin_episode'] > metainfo['end_episode']:
+            metainfo['begin_episode'], metainfo['end_episode'] = metainfo['end_episode'], metainfo['begin_episode']
+        metainfo['total_episode'] = metainfo['end_episode'] - metainfo['begin_episode'] + 1
+    elif metainfo.get('begin_episode') and not metainfo.get('end_episode'):
+        metainfo['total_episode'] = 1
+    return title, metainfo

app/core/module.py

@@ -1,8 +1,12 @@
-from typing import Generator, Optional
+import traceback
+from typing import Generator, Optional, Tuple, Any, Union, List
 
 from app.core.config import settings
+from app.core.event import eventmanager
 from app.helper.module import ModuleHelper
 from app.log import logger
+from app.schemas.types import EventType, ModuleType, DownloaderType, MediaServerType, MessageChannel, StorageSchema, \
+    OtherModulesType
 from app.utils.object import ObjectUtils
 from app.utils.singleton import Singleton
 
@@ -16,6 +20,8 @@ class ModuleManager(metaclass=Singleton):
     _modules: dict = {}
     # 运行态模块列表
     _running_modules: dict = {}
+    # 子模块类型集合
+    SubType = Union[DownloaderType, MediaServerType, MessageChannel, StorageSchema, OtherModulesType]
 
     def __init__(self):
         self.load_modules()
@@ -34,22 +40,54 @@ class ModuleManager(metaclass=Singleton):
         for module in modules:
             module_id = module.__name__
             self._modules[module_id] = module
-            # 生成实例
-            _module = module()
-            # 初始化模块
-            if self.check_setting(_module.init_setting()):
-                # 通过模板开关控制加载
-                _module.init_module()
-                self._running_modules[module_id] = _module
-                logger.info(f"Moudle Loaded：{module_id}")
+            try:
+                # 生成实例
+                _module = module()
+                # 初始化模块
+                if self.check_setting(_module.init_setting()):
+                    # 通过模板开关控制加载
+                    _module.init_module()
+                    self._running_modules[module_id] = _module
+                    logger.info(f"Moudle Loaded：{module_id}")
+            except Exception as err:
+                logger.error(f"Load Moudle Error：{module_id}，{str(err)} - {traceback.format_exc()}", exc_info=True)
 
     def stop(self):
         """
         停止所有模块
         """
-        for _, module in self._running_modules.items():
+        logger.info("正在停止所有模块...")
+        for module_id, module in self._running_modules.items():
             if hasattr(module, "stop"):
-                module.stop()
+                try:
+                    module.stop()
+                    logger.info(f"Moudle Stoped：{module_id}")
+                except Exception as err:
+                    logger.error(f"Stop Moudle Error：{module_id}，{str(err)} - {traceback.format_exc()}", exc_info=True)
+        logger.info("所有模块停止完成")
+
+    def reload(self):
+        """
+        重新加载所有模块
+        """
+        self.stop()
+        self.load_modules()
+        eventmanager.send_event(etype=EventType.ModuleReload, data={})
+
+    def test(self, modleid: str) -> Tuple[bool, str]:
+        """
+        测试模块
+        """
+        if modleid not in self._running_modules:
+            return False, ""
+        module = self._running_modules[modleid]
+        if hasattr(module, "test") \
+                and ObjectUtils.check_method(getattr(module, "test")):
+            result = module.test()
+            if not result:
+                return False, ""
+            return result
+        return True, "模块不支持测试"
 
     @staticmethod
     def check_setting(setting: Optional[tuple]) -> bool:
@@ -59,19 +97,76 @@ class ModuleManager(metaclass=Singleton):
         if not setting:
             return True
         switch, value = setting
-        if getattr(settings, switch) and value is True:
+        option = getattr(settings, switch)
+        if not option:
+            return False
+        if option and value is True:
             return True
-        if value in getattr(settings, switch):
+        if value in option:
             return True
         return False
 
-    def get_modules(self, method: str) -> Generator:
+    def get_running_module(self, module_id: str) -> Any:
+        """
+        根据模块id获取模块运行实例
+        """
+        if not module_id:
+            return None
+        if not self._running_modules:
+            return None
+        return self._running_modules.get(module_id)
+
+    def get_running_modules(self, method: str) -> Generator:
         """
         获取实现了同一方法的模块列表
         """
         if not self._running_modules:
-            return []
+            return
         for _, module in self._running_modules.items():
             if hasattr(module, method) \
                     and ObjectUtils.check_method(getattr(module, method)):
                 yield module
+
+    def get_running_type_modules(self, module_type: ModuleType) -> Generator:
+        """
+        获取指定类型的模块列表
+        """
+        if not self._running_modules:
+            return
+        for _, module in self._running_modules.items():
+            if hasattr(module, 'get_type') \
+                    and module.get_type() == module_type:
+                yield module
+
+    def get_running_subtype_module(self, module_subtype: SubType) -> Generator:
+        """
+        获取指定子类型的模块
+        """
+        if not self._running_modules:
+            return
+        for _, module in self._running_modules.items():
+            if hasattr(module, 'get_subtype') \
+                    and module.get_subtype() == module_subtype:
+                yield module
+
+    def get_module(self, module_id: str) -> Any:
+        """
+        根据模块id获取模块
+        """
+        if not module_id:
+            return None
+        if not self._modules:
+            return None
+        return self._modules.get(module_id)
+
+    def get_modules(self) -> dict:
+        """
+        获取模块列表
+        """
+        return self._modules
+
+    def get_module_ids(self) -> List[str]:
+        """
+        获取模块id列表
+        """
+        return list(self._modules.keys())