- 修复历史记录重新整理时路径不正确的问题

Merge pull request #1234 from thsrite/main
- 修复整理时不自动创建目标路径的问题
2026-05-10 06:22:48 +08:00 · 2023-12-16 12:21:22 +08:00 · 2023-12-14 06:28:50 +08:00 · 2023-12-13 06:53:11 +08:00 · 2023-12-12 14:01:14 +08:00 · 2023-12-11 19:31:19 +08:00
72 changed files with 1423 additions and 585 deletions
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -110,7 +110,7 @@ jobs:

      - name: Pyinstaller
        run: |
-          pyinstaller windows.spec
+          pyinstaller frozen.spec
        shell: pwsh

      - name: Upload Windows File
@@ -119,10 +119,54 @@ jobs:
          name: windows
          path: dist/MoviePilot.exe

+  Linux-build-amd64:
+    runs-on: ubuntu-latest
+    name: Build Linux Amd64
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Init Python 3.11.4
+        uses: actions/setup-python@v4
+        with:
+          python-version: '3.11.4'
+          cache: 'pip'
+
+      - name: Install Dependent Packages
+        run: |
+          python -m pip install --upgrade pip
+          pip install wheel pyinstaller
+          pip install -r requirements.txt
+
+      - name: Prepare Frontend
+        run: |
+          wget https://github.com/jxxghp/MoviePilot-Plugins/archive/refs/heads/main.zip
+          unzip main.zip
+          mv MoviePilot-Plugins-main/plugins/* app/plugins/
+          rm main.zip
+          rm -rf MoviePilot-Plugins-main
+          
+          wget https://github.com/jxxghp/MoviePilot-Resources/archive/refs/heads/main.zip
+          unzip main.zip
+          mv MoviePilot-Resources-main/resources/* app/helper/
+          rm main.zip
+          rm -rf MoviePilot-Resources-main
+
+      - name: Pyinstaller
+        run: |
+          pyinstaller frozen.spec
+          mv dist/MoviePilot dist/MoviePilot_Amd64
+
+      - name: Upload Linux File
+        uses: actions/upload-artifact@v3
+        with:
+          name: linux-amd64
+          path: dist/MoviePilot_Amd64
+
  Create-release:
    permissions: write-all
    runs-on: ubuntu-latest
-    needs: [ Windows-build, Docker-build ]
+    needs: [ Windows-build, Docker-build, Linux-build-amd64]
    steps:
      - uses: actions/checkout@v2

@@ -139,7 +183,8 @@ jobs:
        shell: bash
        run: |
          mkdir releases
-          mv ./windows/MoviePilot.exe ./releases/MoviePilot_v${{ env.app_version }}.exe
+          mv ./windows/MoviePilot.exe ./releases/MoviePilot_Win_v${{ env.app_version }}.exe
+          mv ./linux-amd64/MoviePilot_Amd64 ./releases/MoviePilot_Amd64_v${{ env.app_version }}

      - name: Create Release
        id: create_release
--- a/1
+++ b/1
@@ -32,6 +32,7 @@ RUN apt-get update -y \
        haproxy \
        fuse3 \
        rsync \
+        ffmpeg \
    && \
    if [ "$(uname -m)" = "x86_64" ]; \
        then ln -s /usr/lib/x86_64-linux-musl/libc.so /lib/libc.musl-x86_64.so.1; \
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@
 发布频道：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
 - 聚焦核心需求，简化功能和设置，部分设置项可直接使用默认值。
 - 重新设计了用户界面，更加美观易用。

@@ -39,11 +39,13 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
  docker pull jxxghp/moviepilot:latest
  ```

-
 - Windows

-  下载 [MoviePilot.exe](https://github.com/jxxghp/MoviePilot/releases)，双击运行后自动生成配置文件目录。
+  下载 [MoviePilot.exe](https://github.com/jxxghp/MoviePilot/releases)，双击运行后自动生成配置文件目录，访问：http://localhost:3000

+- 群晖套件
+
+  添加套件源：https://spk7.imnks.com/

 - 本地运行

@@ -51,46 +53,73 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
  2) 将工程 [MoviePilot-Resources](https://github.com/jxxghp/MoviePilot-Resources) resources目录下的所有文件复制到`app/helper`目录
  3) 执行命令：`pip install -r requirements.txt` 安装依赖
  4) 执行命令：`python app/main.py` 启动服务
+  5) 根据前端项目 [MoviePilot-Frontend](https://github.com/jxxghp/MoviePilot-Frontend) 说明，启动前端服务

 ## 配置

-项目的所有配置均通过环境变量进行设置，支持两种配置方式：
- 在Docker环境变量部分或Windows系统环境变量中进行参数配置，如未自动显示配置项则需要手动增加对应环境变量。
- 下载 [app.env](https://github.com/jxxghp/MoviePilot/raw/main/config/app.env) 配置文件，修改好配置后放置到配置文件映射路径根目录，配置项可根据说明自主增减。
-
 配置文件映射路径：`/config`，配置项生效优先级：环境变量 > env文件 > 默认值，**部分参数如路径映射、站点认证、权限端口、时区等必须通过环境变量进行配置**。

 > ❗号标识的为必填项，其它为可选项，可选项可删除配置变量从而使用默认值。

-### 1. **基础设置**
+### 1. **环境变量**

- **❗NGINX_PORT：** WEB服务端口，默认`3000`，可自行修改，不能与API服务端口冲突（仅支持环境变量配置）
- **❗PORT：** API服务端口，默认`3001`，可自行修改，不能与WEB服务端口冲突（仅支持环境变量配置）
- **PUID**：运行程序用户的`uid`，默认`0`（仅支持环境变量配置）
- **PGID**：运行程序用户的`gid`，默认`0`（仅支持环境变量配置）
- **UMASK**：掩码权限，默认`000`，可以考虑设置为`022`（仅支持环境变量配置）
- **PROXY_HOST：** 网络代理，访问themoviedb或者重启更新需要使用代理访问，格式为`http(s)://ip:port`、`socks5://user:pass@host:port`（仅支持环境变量配置）
- **MOVIEPILOT_AUTO_UPDATE**：重启更新，`true`/`release`/`dev`/`false`，默认`release` **注意：如果出现网络问题可以配置`PROXY_HOST`**（仅支持环境变量配置）
---
- **❗SUPERUSER：** 超级管理员用户名，默认`admin`，安装后使用该用户登录后台管理界面
- **❗SUPERUSER_PASSWORD：** 超级管理员初始密码，默认`password`，建议修改为复杂密码
+- **❗NGINX_PORT：** WEB服务端口，默认`3000`，可自行修改，不能与API服务端口冲突
+- **❗PORT：** API服务端口，默认`3001`，可自行修改，不能与WEB服务端口冲突
+- **PUID**：运行程序用户的`uid`，默认`0`
+- **PGID**：运行程序用户的`gid`，默认`0`
+- **UMASK**：掩码权限，默认`000`，可以考虑设置为`022`
+- **PROXY_HOST：** 网络代理，访问themoviedb或者重启更新需要使用代理访问，格式为`http(s)://ip:port`、`socks5://user:pass@host:port`
+- **MOVIEPILOT_AUTO_UPDATE：** 重启时自动更新，`true`/`release`/`dev`/`false`，默认`release`，需要能正常连接Github **注意：如果出现网络问题可以配置`PROXY_HOST`**
+- **AUTO_UPDATE_RESOURCE**：启动时自动检测和更新资源包（站点索引及认证等），`true`/`false`，默认`true`，需要能正常连接Github，仅支持Docker
+- **❗AUTH_SITE：** 认证站点（认证通过后才能使用站点相关功能），支持配置多个认证站点，使用`,`分隔，如：`iyuu,hhclub`，会依次执行认证操作，直到有一个站点认证成功。  
+
+  配置`AUTH_SITE`后，需要根据下表配置对应站点的认证参数，认证资源`v1.0.2`支持`iyuu`/`hhclub`/`audiences`/`hddolby`/`zmpt`/`freefarm`/`hdfans`/`wintersakura`/`leaves`/`1ptba`/`icc2022`/`ptlsp`/`xingtan`/`ptvicomo`/`agsvpt`
+  
+  |      站点      |                          参数                           |
+  |:------------:|:-----------------------------------------------------:|
+  |     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`：密钥      |
+  |   ptvicomo   |     `PTVICOMO_UID`：用户ID<br/>`PTVICOMO_PASSKEY`：密钥     |
+  |    agsvpt    |      `AGSVPT_UID`：用户ID<br/>`AGSVPT_PASSKEY`：密钥       |
+
+
+### 2. **app.env配置文件**
+
+下载 [app.env 模板](https://github.com/jxxghp/MoviePilot/raw/main/config/app.env)，修改后放配置文件目录下，app.env 的所有配置项也可以通过环境变量进行配置。
+
+- **❗SUPERUSER：** 超级管理员用户名，默认`admin`，安装后使用该用户登录后台管理界面，**注意：启动一次后再次修改该值不会生效，除非删除数据库文件！**
+- **❗SUPERUSER_PASSWORD：** 超级管理员初始密码，默认`password`，建议修改为复杂密码，**注意：启动一次后再次修改该值不会生效，除非删除数据库文件！**
 - **❗API_TOKEN：** API密钥，默认`moviepilot`，在媒体服务器Webhook、微信回调等地址配置中需要加上`?token=`该值，建议修改为复杂字符串
- **TMDB_API_DOMAIN：** TMDB API地址，默认`api.themoviedb.org`，也可配置为`api.tmdb.org`或其它中转代理服务地址，能连通即可
+- **BIG_MEMORY_MODE：** 大内存模式，默认为`false`，开启后会增加缓存数量，占用更多的内存，但响应速度会更快
+- **GITHUB_TOKEN：** Github token，提高自动更新、插件安装等请求Github Api的限流阈值，格式：ghp_****
+---
+- **TMDB_API_DOMAIN：** TMDB API地址，默认`api.themoviedb.org`，也可配置为`api.tmdb.org`、`tmdb.movie-pilot.org` 或其它中转代理服务地址，能连通即可
 - **TMDB_IMAGE_DOMAIN：** TMDB图片地址，默认`image.tmdb.org`，可配置为其它中转代理以加速TMDB图片显示，如：`static-mdb.v.geilijiasu.com`
 - **WALLPAPER：** 登录首页电影海报，`tmdb`/`bing`，默认`tmdb`
 - **RECOGNIZE_SOURCE：** 媒体信息识别来源，`themoviedb`/`douban`，默认`themoviedb`，使用`douban`时不支持二级分类
- **SCRAP_SOURCE：** 刮削元数据及图片使用的数据源，`themoviedb`/`douban`，默认`themoviedb`
 ---
 - **SCRAP_METADATA：** 刮削入库的媒体文件，`true`/`false`，默认`true`
+- **SCRAP_SOURCE：** 刮削元数据及图片使用的数据源，`themoviedb`/`douban`，默认`themoviedb`
 - **SCRAP_FOLLOW_TMDB：** 新增已入库媒体是否跟随TMDB信息变化，`true`/`false`，默认`true`，为`false`时即使TMDB信息变化了也会仍然按历史记录中已入库的信息进行刮削
 ---
- **❗TRANSFER_TYPE：** 整理转移方式，支持`link`/`copy`/`move`/`softlink`/`rclone_copy`/`rclone_move`  **注意：在`link`和`softlink`转移方式下，转移后的文件会继承源文件的权限掩码，不受`UMASK`影响；rclone需要自行映射rclone配置目录到容器中或在容器内完成rclone配置，节点名称必须为：`MP`**
- **❗OVERWRITE_MODE：** 转移覆盖模式，默认为`size`，支持`nerver`/`size`/`always`/`latest`，分别表示`不覆盖同名文件`/`同名文件根据文件大小覆盖（大覆盖小）`/`总是覆盖同名文件`/`仅保留最新版本，删除旧版本文件（包括非同名文件）`
 - **❗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`/`rclone_copy`/`rclone_move`  **注意：在`link`和`softlink`转移方式下，转移后的文件会继承源文件的权限掩码，不受`UMASK`影响；rclone需要自行映射rclone配置目录到容器中或在容器内完成rclone配置，节点名称必须为：`MP`**
+- **OVERWRITE_MODE：** 转移覆盖模式，默认为`size`，支持`nerver`/`size`/`always`/`latest`，分别表示`不覆盖同名文件`/`同名文件根据文件大小覆盖（大覆盖小）`/`总是覆盖同名文件`/`仅保留最新版本，删除旧版本文件（包括非同名文件）`
 ---
 - **❗COOKIECLOUD_HOST：** CookieCloud服务器地址，格式：`http(s)://ip:port`，不配置默认使用内建服务器`https://movie-pilot.org/cookiecloud`
 - **❗COOKIECLOUD_KEY：** CookieCloud用户KEY
@@ -104,7 +133,6 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
 - **AUTO_DOWNLOAD_USER：** 远程交互搜索时自动择优下载的用户ID（消息通知渠道的用户ID），多个用户使用,分割，未设置需要选择资源或者回复`0`
 ---
 - **OCR_HOST：** OCR识别服务器地址，格式：`http(s)://ip:port`，用于识别站点验证码实现自动登录获取Cookie等，不配置默认使用内建服务器`https://movie-pilot.org`，可使用 [这个镜像](https://hub.docker.com/r/jxxghp/moviepilot-ocr) 自行搭建。
- **PLUGIN_MARKET：** 插件市场仓库地址，多个地址使用`,`分隔，保留最后的/，默认为官方插件仓库：`https://raw.githubusercontent.com/jxxghp/MoviePilot-Plugins/main/`。
 ---
 - **❗MESSAGER：** 消息通知渠道，支持 `telegram`/`wechat`/`slack`/`synologychat`，开启多个渠道时使用`,`分隔。同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`telegram`

@@ -135,7 +163,6 @@ MoviePilot需要配套下载器和媒体服务器配合使用。

    - **SYNOLOGYCHAT_WEBHOOK：** 在Synology Chat中创建机器人，获取机器人`传入URL`
    - **SYNOLOGYCHAT_TOKEN：** SynologyChat机器人`令牌`
-
 ---
 - **❗DOWNLOAD_PATH：** 下载保存目录，**注意：需要将`moviepilot`及`下载器`的映射路径保持一致**，否则会导致下载文件无法转移
 - **DOWNLOAD_MOVIE_PATH：** 电影下载保存目录路径，不设置则下载到`DOWNLOAD_PATH`
@@ -143,8 +170,7 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
 - **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`
- **DOWNLOADER_MONITOR：** 下载器监控，`true`/`false`，默认为`true`，开启后下载完成时才会自动整理入库
- **TORRENT_TAG：** 下载器种子标签，默认为`MOVIEPILOT`，设置后只有MoviePilot添加的下载才会处理，留空所有下载器中的任务均会处理
+---
 - **❗DOWNLOADER：** 下载器，支持`qbittorrent`/`transmission`，QB版本号要求>= 4.3.9，TR版本号要求>= 3.0，同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`qbittorrent`

  - `qbittorrent`设置项：
@@ -161,7 +187,8 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
    - **TR_HOST：** transmission地址，格式：`ip:port`，https需要添加`https://`前缀
    - **TR_USER：** transmission用户名
    - **TR_PASSWORD：** transmission密码
-
+- **DOWNLOADER_MONITOR：** 下载器监控，`true`/`false`，默认为`true`，开启后下载完成时才会自动整理入库
+- **TORRENT_TAG：** 下载器种子标签，默认为`MOVIEPILOT`，设置后只有MoviePilot添加的下载才会处理，留空所有下载器中的任务均会处理
 ---
 - **❗MEDIASERVER：** 媒体服务器，支持`emby`/`jellyfin`/`plex`，同时开启多个使用`,`分隔。还需要配置对应媒体服务器的环境变量，非对应媒体服务器的变量可删除，推荐使用`emby`

@@ -179,87 +206,55 @@ MoviePilot需要配套下载器和媒体服务器配合使用。

    - **PLEX_HOST：** Plex服务器地址，格式：`ip:port`，https需要添加`https://`前缀
    - **PLEX_TOKEN：** Plex网页Url中的`X-Plex-Token`，通过浏览器F12->网络从请求URL中获取
-
 - **MEDIASERVER_SYNC_INTERVAL:** 媒体服务器同步间隔（小时），默认`6`，留空则不同步
 - **MEDIASERVER_SYNC_BLACKLIST:** 媒体服务器同步黑名单，多个媒体库名称使用,分割
+---
+- **MOVIE_RENAME_FORMAT：** 电影重命名格式，基于jinjia2语法

+  `MOVIE_RENAME_FORMAT`支持的配置项：

-### 2. **用户认证**
+  > `title`： TMDB/豆瓣中的标题  
+  > `original_title`： TMDB/豆瓣中的原语种标题  
+  > `name`： 从文件名中识别的名称（同时存在中英文时，优先使用中文）
+  > `en_name`：从文件名中识别的英文名称（可能为空）
+  > `original_name`： 原文件名（包括文件外缀）  
+  > `year`： 年份  
+  > `resourceType`：资源类型  
+  > `effect`：特效  
+  > `edition`： 版本（资源类型+特效）  
+  > `videoFormat`： 分辨率  
+  > `releaseGroup`： 制作组/字幕组  
+  > `customization`： 自定义占位符  
+  > `videoCodec`： 视频编码  
+  > `audioCodec`： 音频编码  
+  > `tmdbid`： TMDB ID（非TMDB识别源时为空）  
+  > `imdbid`： IMDB ID（可能为空）  
+  > `doubanid`：豆瓣ID（非豆瓣识别源时为空）  
+  > `part`：段/节  
+  > `fileExt`：文件扩展名
+  > `customization`：自定义占位符
+  
+  `MOVIE_RENAME_FORMAT`默认配置格式：
+  
+  ```
+  {{title}}{% if year %} ({{year}}){% endif %}/{{title}}{% if year %} ({{year}}){% endif %}{% if part %}-{{part}}{% endif %}{% if videoFormat %} - {{videoFormat}}{% endif %}{{fileExt}}
+  ```

-`MoviePilot`需要认证后才能使用，配置`AUTH_SITE`后，需要根据下表配置对应站点的认证参数（**仅能通过环境变量配置**）
-
-`AUTH_SITE`支持配置多个认证站点，使用`,`分隔，如：`iyuu,hhclub`，会依次执行认证操作，直到有一个站点认证成功。
-
- **❗AUTH_SITE：** 认证站点，认证资源`v1.0.1`支持`iyuu`/`hhclub`/`audiences`/`hddolby`/`zmpt`/`freefarm`/`hdfans`/`wintersakura`/`leaves`/`1ptba`/`icc2022`/`ptlsp`/`xingtan`/`ptvicomo`
-
-|      站点      |                          参数                           |
-|:------------:|:-----------------------------------------------------:|
-|     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`：密钥      |
-|   ptvicomo   |     `PTVICOMO_UID`：用户ID<br/>`PTVICOMO_PASSKEY`：密钥     |
-
-
-### 2. **进阶配置**
-
- **BIG_MEMORY_MODE：** 大内存模式，默认为`false`，开启后会增加缓存数量，占用更多的内存，但响应速度会更快
-
- **MOVIE_RENAME_FORMAT：** 电影重命名格式
-
-`MOVIE_RENAME_FORMAT`支持的配置项：
-
-> `title`： 标题  
-> `original_name`： 原文件名  
-> `original_title`： 原语种标题  
-> `name`： 识别名称  
-> `year`： 年份  
-> `resourceType`：资源类型  
-> `effect`：特效  
-> `edition`： 版本（资源类型+特效）  
-> `videoFormat`： 分辨率  
-> `releaseGroup`： 制作组/字幕组  
-> `customization`： 自定义占位符  
-> `videoCodec`： 视频编码  
-> `audioCodec`： 音频编码  
-> `tmdbid`： TMDBID  
-> `imdbid`： IMDBID  
-> `part`：段/节  
-> `fileExt`：文件扩展名
-> `tmdbid`：TMDB ID
-> `imdbid`：IMDB ID
-> `customization`：自定义占位符
-
-`MOVIE_RENAME_FORMAT`默认配置格式：
-
-```
-{{title}}{% if year %} ({{year}}){% endif %}/{{title}}{% if year %} ({{year}}){% endif %}{% if part %}-{{part}}{% endif %}{% if videoFormat %} - {{videoFormat}}{% endif %}{{fileExt}}
-```
-
- **TV_RENAME_FORMAT：** 电视剧重命名格式
-
-`TV_RENAME_FORMAT`额外支持的配置项：
-
-> `season`： 季号  
-> `episode`： 集号  
-> `season_episode`： 季集 SxxExx  
-> `episode_title`： 集标题
-
-`TV_RENAME_FORMAT`默认配置格式：
-
-```
-{{title}}{% if year %} ({{year}}){% endif %}/Season {{season}}/{{title}} - {{season_episode}}{% if part %}-{{part}}{% endif %}{% if episode %} - 第 {{episode}} 集{% endif %}{{fileExt}}
-```
+- **TV_RENAME_FORMAT：** 电视剧重命名格式，基于jinjia2语法

+  `TV_RENAME_FORMAT`额外支持的配置项：
+  
+  > `season`： 季号  
+  > `episode`： 集号  
+  > `season_episode`： 季集 SxxExx  
+  > `episode_title`： 集标题
+  
+  `TV_RENAME_FORMAT`默认配置格式：
+  
+  ```
+  {{title}}{% if year %} ({{year}}){% endif %}/Season {{season}}/{{title}} - {{season_episode}}{% if part %}-{{part}}{% endif %}{% if episode %} - 第 {{episode}} 集{% endif %}{{fileExt}}
+  ```
+  

 ### 3. **优先级规则**

@@ -267,6 +262,10 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
 - 符合任一层级规则的资源将被标识选中，匹配成功的层级做为该资源的优先级，排越前面优先级超高
 - 不符合过滤规则所有层级规则的资源将不会被选中

+### 4. **插件扩展**
+
+- **PLUGIN_MARKET：** 插件市场仓库地址，仅支持Github仓库`main`分支，多个地址使用`,`分隔，默认为官方插件仓库：`https://github.com/jxxghp/MoviePilot-Plugins` ，通过查看[MoviePilot-Plugins](https://github.com/jxxghp/MoviePilot-Plugins)项目的fork，或者查看频道置顶了解更多第三方插件仓库。
+

 ## 使用

--- a/app/api/endpoints/douban.py
+++ b/app/api/endpoints/douban.py
@@ -149,6 +149,47 @@ def tv_hot(page: int = 1,
    return [MediaInfo(douban_info=tv).to_dict() for tv in tvs]


+@router.get("/credits/{doubanid}/{type_name}", summary="豆瓣演员阵容", response_model=List[schemas.DoubanPerson])
+def douban_credits(doubanid: str,
+                   type_name: str,
+                   page: int = 1,
+                   _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据TMDBID查询演员阵容，type_name: 电影/电视剧
+    """
+    mediatype = MediaType(type_name)
+    if mediatype == MediaType.MOVIE:
+        doubaninfos = DoubanChain().movie_credits(doubanid=doubanid, page=page)
+    elif mediatype == MediaType.TV:
+        doubaninfos = DoubanChain().tv_credits(doubanid=doubanid, page=page)
+    else:
+        return []
+    if not doubaninfos:
+        return []
+    else:
+        return [schemas.DoubanPerson(**doubaninfo) for doubaninfo in doubaninfos]
+
+
+@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: 电影/电视剧
+    """
+    mediatype = MediaType(type_name)
+    if mediatype == MediaType.MOVIE:
+        doubaninfos = DoubanChain().movie_recommend(doubanid=doubanid)
+    elif mediatype == MediaType.TV:
+        doubaninfos = DoubanChain().tv_recommend(doubanid=doubanid)
+    else:
+        return []
+    if not doubaninfos:
+        return []
+    else:
+        return [MediaInfo(douban_info=doubaninfo).to_dict() for doubaninfo in doubaninfos]
+
+
@router.get("/{doubanid}", summary="查询豆瓣详情", response_model=schemas.MediaInfo)
 def douban_info(doubanid: str,
                _: schemas.TokenPayload = Depends(verify_token)) -> Any:
--- a/app/api/endpoints/download.py
+++ b/app/api/endpoints/download.py
@@ -104,7 +104,7 @@ def stop_downloading(
        hashString: str,
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
-    控制下载任务
+    暂停下载任务
    """
    ret = DownloadChain().set_downloading(hashString, "stop")
    return schemas.Response(success=True if ret else False)
@@ -115,7 +115,7 @@ def remove_downloading(
        hashString: str,
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
-    控制下载任务
+    删除下载任务
    """
    ret = DownloadChain().remove_downloading(hashString)
    return schemas.Response(success=True if ret else False)
--- a/app/api/endpoints/media.py
+++ b/app/api/endpoints/media.py
@@ -131,5 +131,6 @@ def media_info(mediaid: str, type_name: str,
                return schemas.MediaInfo()
    mediainfo = MediaChain().recognize_media(tmdbid=tmdbid, doubanid=doubanid, mtype=mtype)
    if mediainfo:
+        MediaChain().obtain_images(mediainfo)
        return mediainfo.to_dict()
    return schemas.MediaInfo()
--- a/app/api/endpoints/plugin.py
+++ b/app/api/endpoints/plugin.py
@@ -62,7 +62,7 @@ def install_plugin(plugin_id: str,
        state, msg = PluginHelper().install(pid=plugin_id, repo_url=repo_url)
        if not state:
            # 安装失败
-            return schemas.Response(success=False, msg=msg)
+            return schemas.Response(success=False, message=msg)
    # 安装插件
    if plugin_id not in install_plugins:
        install_plugins.append(plugin_id)
@@ -89,11 +89,23 @@ def plugin_form(plugin_id: str,
@router.get("/page/{plugin_id}", summary="获取插件数据页面")
 def plugin_page(plugin_id: str, _: schemas.TokenPayload = Depends(verify_token)) -> List[dict]:
    """
-    根据插件ID获取插件配置信息
+    根据插件ID获取插件数据页面
    """
    return PluginManager().get_plugin_page(plugin_id)


+@router.get("/reset/{plugin_id}", summary="重置插件配置", response_model=schemas.Response)
+def reset_plugin(plugin_id: str, _: schemas.TokenPayload = Depends(verify_token)) -> List[dict]:
+    """
+    根据插件ID重置插件配置
+    """
+    # 删除配置
+    PluginManager().delete_plugin_config(plugin_id)
+    # 重新生效插件
+    PluginManager().reload_plugin(plugin_id, {})
+    return schemas.Response(success=True)
+
+
@router.get("/{plugin_id}", summary="获取插件配置")
 def plugin_config(plugin_id: str, _: schemas.TokenPayload = Depends(verify_token)) -> dict:
    """
@@ -106,7 +118,7 @@ def plugin_config(plugin_id: str, _: schemas.TokenPayload = Depends(verify_token
 def set_plugin_config(plugin_id: str, conf: dict,
                      _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
-    根据插件ID获取插件配置信息
+    更新插件配置
    """
    # 保存配置
    PluginManager().save_plugin_config(plugin_id, conf)
--- a/app/api/endpoints/subscribe.py
+++ b/app/api/endpoints/subscribe.py
@@ -82,6 +82,7 @@ def create_subscribe(
                                        doubanid=subscribe_in.doubanid,
                                        username=current_user.name,
                                        best_version=subscribe_in.best_version,
+                                        save_path=subscribe_in.save_path,
                                        exist_ok=True)
    return schemas.Response(success=True if sid else False, message=message, data={
        "id": sid
@@ -122,11 +123,13 @@ def update_subscribe(
 def subscribe_mediaid(
        mediaid: str,
        season: int = None,
+        title: str = None,
        db: Session = Depends(get_db),
        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
    """
    根据TMDBID或豆瓣ID查询订阅 tmdb:/douban:
    """
+    result = None
    if mediaid.startswith("tmdb:"):
        tmdbid = mediaid[5:]
        if not tmdbid or not str(tmdbid).isdigit():
@@ -137,8 +140,13 @@ def subscribe_mediaid(
        if not doubanid:
            return Subscribe()
        result = Subscribe.get_by_doubanid(db, doubanid)
-    else:
-        result = None
+
+    if not result and title:
+        meta = MetaInfo(title)
+        if season:
+            meta.begin_season = season
+        result = Subscribe.get_by_title(db, title=meta.name, season=meta.begin_season)
+
    if result and result.sites:
        result.sites = json.loads(result.sites)

@@ -257,7 +265,7 @@ def delete_subscribe(
 async def seerr_subscribe(request: Request, background_tasks: BackgroundTasks,
                          authorization: str = Header(None)) -> Any:
    """
-    Jellyseerr/Overseerr订阅
+    Jellyseerr/Overseerr网络勾子通知订阅
    """
    if not authorization or authorization != settings.API_TOKEN:
        raise HTTPException(
--- a/app/api/endpoints/system.py
+++ b/app/api/endpoints/system.py
@@ -1,10 +1,10 @@
 import json
 import time
 from datetime import datetime
-from typing import Union
+from typing import Union, Any

 import tailer
-from fastapi import APIRouter, HTTPException, Depends
+from fastapi import APIRouter, HTTPException, Depends, Response
 from fastapi.responses import StreamingResponse

 from app import schemas
@@ -24,6 +24,19 @@ from version import APP_VERSION
 router = APIRouter()


+@router.get("/img/{imgurl:path}", summary="图片代理")
+def get_img(imgurl: str) -> Any:
+    """
+    通过图片代理（使用代理服务器）
+    """
+    if not imgurl:
+        return None
+    response = RequestUtils(ua=settings.USER_AGENT, proxies=settings.PROXY).get_res(url=imgurl)
+    if response:
+        return Response(content=response.content, media_type="image/jpeg")
+    return None
+
+
@router.get("/env", summary="查询系统环境变量", response_model=schemas.Response)
 def get_env_setting(_: schemas.TokenPayload = Depends(verify_token)):
    """
@@ -163,7 +176,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:
--- a/app/api/endpoints/transfer.py
+++ b/app/api/endpoints/transfer.py
@@ -47,9 +47,11 @@ def manual_transfer(path: str = None,
    :param _: Token校验
    """
    force = False
+    target = Path(target) if target else None
+    transfer = TransferChain()
    if logid:
        # 查询历史记录
-        history = TransferHistory.get(db, logid)
+        history: TransferHistory = TransferHistory.get(db, logid)
        if not history:
            return schemas.Response(success=False, message=f"历史记录不存在，ID：{logid}")
        # 强制转移
@@ -59,19 +61,16 @@ def manual_transfer(path: str = None,
        # 目的路径
        if history.dest and str(history.dest) != "None":
            # 删除旧的已整理文件
-            TransferChain().delete_files(Path(history.dest))
+            transfer.delete_files(Path(history.dest))
            if not target:
-                target = history.dest
+                target = transfer.get_root_path(path=history.dest,
+                                                type_name=history.type,
+                                                category=history.category)
    elif path:
        in_path = Path(path)
    else:
        return schemas.Response(success=False, message=f"缺少参数：path/logid")

-    if target and target != "None":
-        target = Path(target)
-    else:
-        target = None
-
    # 类型
    mtype = MediaType(type_name) if type_name else None
    # 自定义格式
@@ -84,7 +83,7 @@ def manual_transfer(path: str = None,
            offset=episode_offset,
        )
    # 开始转移
-    state, errormsg = TransferChain().manual_transfer(
+    state, errormsg = transfer.manual_transfer(
        in_path=in_path,
        target=target,
        tmdbid=tmdbid,
--- a/app/chain/douban.py
+++ b/app/chain/douban.py
@@ -72,3 +72,33 @@ class DoubanChain(ChainBase, metaclass=Singleton):
        if settings.RECOGNIZE_SOURCE != "douban":
            return None
        return self.run_module("tv_hot", page=page, count=count)
+
+    def movie_credits(self, doubanid: str, page: int = 1) -> List[dict]:
+        """
+        根据TMDBID查询电影演职人员
+        :param doubanid:  豆瓣ID
+        :param page:  页码
+        """
+        return self.run_module("douban_movie_credits", doubanid=doubanid, page=page)
+
+    def tv_credits(self, doubanid: str, page: int = 1) -> List[dict]:
+        """
+        根据TMDBID查询电视剧演职人员
+        :param doubanid:  豆瓣ID
+        :param page:  页码
+        """
+        return self.run_module("douban_tv_credits", doubanid=doubanid, page=page)
+
+    def movie_recommend(self, doubanid: str) -> List[dict]:
+        """
+        根据豆瓣ID查询推荐电影
+        :param doubanid:  豆瓣ID
+        """
+        return self.run_module("douban_movie_recommend", doubanid=doubanid)
+
+    def tv_recommend(self, doubanid: str) -> List[dict]:
+        """
+        根据豆瓣ID查询推荐电视剧
+        :param doubanid:  豆瓣ID
+        """
+        return self.run_module("douban_tv_recommend", doubanid=doubanid)
--- a/app/chain/download.py
+++ b/app/chain/download.py
@@ -192,7 +192,7 @@ class DownloadChain(ChainBase):
                                                                      channel=channel,
                                                                      userid=userid)
            if not content:
-                return
+                return None
        else:
            content = torrent_file
            # 获取种子文件的文件夹名和文件清单
@@ -283,6 +283,10 @@ class DownloadChain(ChainBase):
                    if not file_meta.begin_episode \
                            or file_meta.begin_episode not in episodes:
                        continue
+                # 只处理视频格式
+                if not Path(file).suffix \
+                        or Path(file).suffix not in settings.RMT_MEDIAEXT:
+                    continue
                files_to_add.append({
                    "download_hash": _hash,
                    "downloader": settings.DOWNLOADER,
--- a/app/chain/mediaserver.py
+++ b/app/chain/mediaserver.py
@@ -52,7 +52,7 @@ class MediaServerChain(ChainBase):
            # 汇总统计
            total_count = 0
            # 清空登记薄
-            self.dboper.empty(server=settings.MEDIASERVER)
+            self.dboper.empty()
            # 同步黑名单
            sync_blacklist = settings.MEDIASERVER_SYNC_BLACKLIST.split(
                ",") if settings.MEDIASERVER_SYNC_BLACKLIST else []
--- a/app/chain/message.py
+++ b/app/chain/message.py
@@ -1,14 +1,22 @@
-from typing import Any
+import copy
+import json
+import re
+from typing import Any, Optional, Dict

-from app.chain.download import *
+from app.chain import ChainBase
+from app.chain.download import DownloadChain
 from app.chain.media import MediaChain
 from app.chain.search import SearchChain
 from app.chain.subscribe import SubscribeChain
-from app.core.context import MediaInfo
+from app.core.config import settings
+from app.core.context import MediaInfo, Context
 from app.core.event import EventManager
+from app.core.meta import MetaBase
+from app.helper.torrent import TorrentHelper
 from app.log import logger
 from app.schemas import Notification
-from app.schemas.types import EventType, MessageChannel
+from app.schemas.types import EventType, MessageChannel, MediaType
+from app.utils.string import StringUtils

 # 当前页面
 _current_page: int = 0
@@ -33,7 +41,6 @@ class MessageChain(ChainBase):
        self.subscribechain = SubscribeChain()
        self.searchchain = SearchChain()
        self.medtachain = MediaChain()
-        self.torrent = TorrentHelper()
        self.eventmanager = EventManager()
        self.torrenthelper = TorrentHelper()

@@ -353,6 +360,13 @@ class MessageChain(ChainBase):
        else:
            # 未完成下载
            logger.info(f'{_current_media.title_year} 未下载未完整，添加订阅 ...')
+            if downloads and _current_media.type == MediaType.TV:
+                # 获取已下载剧集
+                downloaded = [download.meta_info.begin_episode for download in downloads
+                              if download.meta_info.begin_episode]
+                note = json.dumps(downloaded)
+            else:
+                note = None
            # 添加订阅，状态为R
            self.subscribechain.add(title=_current_media.title,
                                    year=_current_media.year,
@@ -362,7 +376,8 @@ class MessageChain(ChainBase):
                                    channel=channel,
                                    userid=userid,
                                    username=username,
-                                    state="R")
+                                    state="R",
+                                    note=note)

    def __post_medias_message(self, channel: MessageChannel,
                              title: str, items: list, userid: str, total: int):
--- a/app/chain/search.py
+++ b/app/chain/search.py
@@ -213,7 +213,7 @@ class SearchChain(ChainBase):
                    continue
                # 在副标题中判断是否存在标题与原语种标题
                if torrent.description:
-                    subtitle = torrent.description.split()
+                    subtitle = re.split(r'[\s/|]+', torrent.description)
                    if (StringUtils.is_chinese(mediainfo.title)
                        and str(mediainfo.title) in subtitle) \
                            or (StringUtils.is_chinese(mediainfo.original_title)
--- a/app/chain/subscribe.py
+++ b/app/chain/subscribe.py
@@ -199,7 +199,8 @@ class SubscribeChain(ChainBase):
                                                        tmdbid=subscribe.tmdbid,
                                                        doubanid=subscribe.doubanid)
            if not mediainfo:
-                logger.warn(f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}')
+                logger.warn(
+                    f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}')
                continue

            # 非洗版状态
@@ -240,7 +241,7 @@ class SubscribeChain(ChainBase):

            # 电视剧订阅处理缺失集
            if meta.type == MediaType.TV:
-                # 使用订阅的总集数和开始集数替换no_exists
+                # 实际缺失集与订阅开始结束集范围进行整合
                no_exists = self.__get_subscribe_no_exits(
                    no_exists=no_exists,
                    mediakey=mediakey,
@@ -249,7 +250,7 @@ class SubscribeChain(ChainBase):
                    start_episode=subscribe.start_episode,

                )
-                # 打印缺失集信息
+                # 打印汇总缺失集信息
                if no_exists and no_exists.get(mediakey):
                    no_exists_info = no_exists.get(mediakey).get(subscribe.season)
                    if no_exists_info:
@@ -279,13 +280,11 @@ class SubscribeChain(ChainBase):
                                                filter_rule=filter_rule)
            if not contexts:
                logger.warn(f'订阅 {subscribe.keyword or subscribe.name} 未搜索到资源')
-                if meta.type == MediaType.TV:
-                    # 未搜索到资源，但本地缺失可能有变化，更新订阅剩余集数
-                    self.__update_lack_episodes(lefts=no_exists, subscribe=subscribe,
-                                                meta=meta, mediainfo=mediainfo)
+                self.finish_subscribe_or_not(subscribe=subscribe, meta=meta,
+                                             mediainfo=mediainfo, lefts=no_exists)
                continue

-            # 过滤
+            # 过滤搜索结果
            matched_contexts = []
            for context in contexts:
                torrent_meta = context.meta_info
@@ -304,41 +303,30 @@ class SubscribeChain(ChainBase):
                        if torrent_meta.episode_list:
                            logger.info(f'{subscribe.name} 正在洗版，{torrent_info.title} 不是整季')
                            continue
-                    # 优先级小于已下载优先级的不要
+                    # 洗版时，优先级小于已下载优先级的不要
                    if subscribe.current_priority \
                            and torrent_info.pri_order < subscribe.current_priority:
                        logger.info(f'{subscribe.name} 正在洗版，{torrent_info.title} 优先级低于已下载优先级')
                        continue
                matched_contexts.append(context)
+
            if not matched_contexts:
                logger.warn(f'订阅 {subscribe.name} 没有符合过滤条件的资源')
-                # 非洗版未搜索到资源，但本地缺失可能有变化，更新订阅剩余集数
-                if meta.type == MediaType.TV and not subscribe.best_version:
-                    self.__update_lack_episodes(lefts=no_exists, subscribe=subscribe,
-                                                meta=meta, mediainfo=mediainfo)
+                self.finish_subscribe_or_not(subscribe=subscribe, meta=meta,
+                                             mediainfo=mediainfo, lefts=no_exists)
                continue

            # 自动下载
-            downloads, lefts = self.downloadchain.batch_download(contexts=matched_contexts,
-                                                                 no_exists=no_exists, username=subscribe.username)
-            # 更新已经下载的集数
-            if downloads \
-                    and meta.type == MediaType.TV \
-                    and not subscribe.best_version:
-                self.__update_subscribe_note(subscribe=subscribe, downloads=downloads)
+            downloads, lefts = self.downloadchain.batch_download(
+                contexts=matched_contexts,
+                no_exists=no_exists,
+                username=subscribe.username,
+                save_path=subscribe.save_path
+            )

-            if downloads and not lefts:
-                # 判断是否应完成订阅
-                self.finish_subscribe_or_not(subscribe=subscribe, meta=meta,
-                                             mediainfo=mediainfo, downloads=downloads)
-            else:
-                # 未完成下载
-                logger.info(f'{mediainfo.title_year} 未下载完整，继续订阅 ...')
-                if meta.type == MediaType.TV and not subscribe.best_version:
-                    # 更新订阅剩余集数和时间
-                    update_date = True if downloads else False
-                    self.__update_lack_episodes(lefts=lefts, subscribe=subscribe, meta=meta,
-                                                mediainfo=mediainfo, update_date=update_date)
+            # 判断是否应完成订阅
+            self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo,
+                                         downloads=downloads, lefts=lefts)

        # 手动触发时发送系统消息
        if manual:
@@ -347,35 +335,67 @@ class SubscribeChain(ChainBase):
            else:
                self.message.put('所有订阅搜索完成！')

-    def finish_subscribe_or_not(self, subscribe: Subscribe, meta: MetaInfo,
-                                mediainfo: MediaInfo, downloads: List[Context] = None):
+    def update_subscribe_priority(self, subscribe: Subscribe, meta: MetaInfo,
+                                  mediainfo: MediaInfo, downloads: List[Context]):
+        """
+        更新订阅已下载资源的优先级
+        """
+        if not downloads:
+            return
+        if not subscribe.best_version:
+            return
+        # 当前下载资源的优先级
+        priority = max([item.torrent_info.pri_order for item in downloads])
+        if priority == 100:
+            logger.info(f'{mediainfo.title_year} 洗版完成，删除订阅')
+            self.subscribeoper.delete(subscribe.id)
+            # 发送通知
+            self.post_message(Notification(mtype=NotificationType.Subscribe,
+                                           title=f'{mediainfo.title_year} {meta.season} 已洗版完成',
+                                           image=mediainfo.get_message_image()))
+        else:
+            # 正在洗版，更新资源优先级
+            logger.info(f'{mediainfo.title_year} 正在洗版，更新资源优先级为 {priority}')
+            self.subscribeoper.update(subscribe.id, {
+                "current_priority": priority
+            })
+
+    def finish_subscribe_or_not(self, subscribe: Subscribe, meta: MetaInfo, mediainfo: MediaInfo,
+                                downloads: List[Context] = None,
+                                lefts: Dict[Union[int | str], Dict[int, NotExistMediaInfo]] = None):
        """
        判断是否应完成订阅
        """
        if not subscribe.best_version:
-            # 全部下载完成
-            logger.info(f'{mediainfo.title_year} 完成订阅')
-            self.subscribeoper.delete(subscribe.id)
-            # 发送通知
-            self.post_message(Notification(mtype=NotificationType.Subscribe,
-                                           title=f'{mediainfo.title_year} {meta.season} 已完成订阅',
-                                           image=mediainfo.get_message_image()))
-        elif downloads:
-            # 当前下载资源的优先级
-            priority = max([item.torrent_info.pri_order for item in downloads])
-            if priority == 100:
-                logger.info(f'{mediainfo.title_year} 洗版完成，删除订阅')
+            # 非洗板
+            if (not lefts and meta.type == MediaType.TV) or (downloads and meta.type == MediaType.MOVIE):
+                # 全部下载完成
+                logger.info(f'{mediainfo.title_year} 完成订阅')
                self.subscribeoper.delete(subscribe.id)
                # 发送通知
                self.post_message(Notification(mtype=NotificationType.Subscribe,
-                                               title=f'{mediainfo.title_year} {meta.season} 已洗版完成',
+                                               title=f'{mediainfo.title_year} {meta.season} 已完成订阅',
                                               image=mediainfo.get_message_image()))
+            elif downloads and meta.type == MediaType.TV:
+                # 电视剧更新已下载集数
+                self.__update_subscribe_note(subscribe=subscribe, downloads=downloads)
+                # 更新订阅剩余集数和时间
+                self.__update_lack_episodes(lefts=lefts, subscribe=subscribe,
+                                            mediainfo=mediainfo, update_date=True)
            else:
-                # 正在洗版，更新资源优先级
-                logger.info(f'{mediainfo.title_year} 正在洗版，更新资源优先级')
-                self.subscribeoper.update(subscribe.id, {
-                    "current_priority": priority
-                })
+                # 未下载到内容且不完整
+                logger.info(f'{mediainfo.title_year} 未下载完整，继续订阅 ...')
+                if meta.type == MediaType.TV:
+                    # 更新订阅剩余集数
+                    self.__update_lack_episodes(lefts=lefts, subscribe=subscribe,
+                                                mediainfo=mediainfo, update_date=False)
+        elif downloads:
+            # 洗板，下载到了内容，更新资源优先级
+            self.update_subscribe_priority(subscribe=subscribe, meta=meta,
+                                           mediainfo=mediainfo, downloads=downloads)
+        else:
+            # 洗版，未下载到内容
+            logger.info(f'{mediainfo.title_year} 继续洗版 ...')

    def refresh(self):
        """
@@ -495,9 +515,11 @@ class SubscribeChain(ChainBase):
            meta.type = MediaType(subscribe.type)
            # 识别媒体信息
            mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type,
-                                                        tmdbid=subscribe.tmdbid, doubanid=subscribe.doubanid)
+                                                        tmdbid=subscribe.tmdbid,
+                                                        doubanid=subscribe.doubanid)
            if not mediainfo:
-                logger.warn(f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}')
+                logger.warn(
+                    f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}')
                continue
            # 非洗版
            if not subscribe.best_version:
@@ -537,7 +559,7 @@ class SubscribeChain(ChainBase):

            # 电视剧订阅
            if meta.type == MediaType.TV:
-                # 使用订阅的总集数和开始集数替换no_exists
+                # 整合实际缺失集与订阅开始集结束集
                no_exists = self.__get_subscribe_no_exits(
                    no_exists=no_exists,
                    mediakey=mediakey,
@@ -546,7 +568,7 @@ class SubscribeChain(ChainBase):
                    start_episode=subscribe.start_episode,

                )
-                # 打印缺失集信息
+                # 打印汇总缺失集信息
                if no_exists and no_exists.get(mediakey):
                    no_exists_info = no_exists.get(mediakey).get(subscribe.season)
                    if no_exists_info:
@@ -633,35 +655,33 @@ class SubscribeChain(ChainBase):
                                                  filter_rule=filter_rule):
                        continue

+                    # 洗版时，优先级小于已下载优先级的不要
+                    if subscribe.best_version:
+                        if subscribe.current_priority \
+                                and torrent_info.pri_order < subscribe.current_priority:
+                            logger.info(f'{subscribe.name} 正在洗版，{torrent_info.title} 优先级低于已下载优先级')
+                            continue
+
                    # 匹配成功
                    logger.info(f'{mediainfo.title_year} 匹配成功：{torrent_info.title}')
                    _match_context.append(context)

-            # 开始下载
-            logger.info(f'{mediainfo.title_year} 匹配完成，共匹配到{len(_match_context)}个资源')
-            if _match_context:
-                # 批量择优下载
-                downloads, lefts = self.downloadchain.batch_download(contexts=_match_context, no_exists=no_exists,
-                                                                     username=subscribe.username)
-                # 更新已经下载的集数
-                if downloads and meta.type == MediaType.TV:
-                    self.__update_subscribe_note(subscribe=subscribe, downloads=downloads)
+            if not _match_context:
+                # 未匹配到资源
+                logger.info(f'{mediainfo.title_year} 未匹配到符合条件的资源')
+                self.finish_subscribe_or_not(subscribe=subscribe, meta=meta,
+                                             mediainfo=mediainfo, lefts=no_exists)
+                continue

-                if downloads and not lefts:
-                    # 判断是否要完成订阅
-                    self.finish_subscribe_or_not(subscribe=subscribe, meta=meta,
-                                                 mediainfo=mediainfo, downloads=downloads)
-                else:
-                    if meta.type == MediaType.TV and not subscribe.best_version:
-                        update_date = True if downloads else False
-                        # 未完成下载，计算剩余集数
-                        self.__update_lack_episodes(lefts=lefts, subscribe=subscribe, meta=meta,
-                                                    mediainfo=mediainfo, update_date=update_date)
-            else:
-                if meta.type == MediaType.TV:
-                    # 未搜索到资源，但本地缺失可能有变化，更新订阅剩余集数
-                    self.__update_lack_episodes(lefts=no_exists, subscribe=subscribe,
-                                                meta=meta, mediainfo=mediainfo)
+            # 开始批量择优下载
+            logger.info(f'{mediainfo.title_year} 匹配完成，共匹配到{len(_match_context)}个资源')
+            downloads, lefts = self.downloadchain.batch_download(contexts=_match_context,
+                                                                 no_exists=no_exists,
+                                                                 username=subscribe.username,
+                                                                 save_path=subscribe.save_path)
+            # 判断是否要完成订阅
+            self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo,
+                                         downloads=downloads, lefts=lefts)

    def check(self):
        """
@@ -684,7 +704,8 @@ class SubscribeChain(ChainBase):
            mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type,
                                                        tmdbid=subscribe.tmdbid, doubanid=subscribe.doubanid)
            if not mediainfo:
-                logger.warn(f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}')
+                logger.warn(
+                    f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}')
                continue
            # 对于电视剧，获取当前季的总集数
            episodes = mediainfo.seasons.get(subscribe.season) or []
@@ -756,14 +777,15 @@ class SubscribeChain(ChainBase):
            return True
        return False

-    def __update_lack_episodes(self, lefts: Dict[int, Dict[int, NotExistMediaInfo]],
+    def __update_lack_episodes(self, lefts: Dict[Union[int, str], Dict[int, NotExistMediaInfo]],
                               subscribe: Subscribe,
-                               meta: MetaBase,
                               mediainfo: MediaInfo,
                               update_date: bool = False):
        """
        更新订阅剩余集数
        """
+        if not lefts:
+            return
        mediakey = subscribe.tmdbid or subscribe.doubanid
        left_seasons = lefts.get(mediakey)
        if left_seasons:
@@ -786,9 +808,6 @@ class SubscribeChain(ChainBase):
                        self.subscribeoper.update(subscribe.id, {
                            "lack_episode": lack_episode
                        })
-        else:
-            # 判断是否应完成订阅
-            self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo)

    def remote_list(self, channel: MessageChannel, userid: Union[str, int] = None):
        """
@@ -850,7 +869,7 @@ class SubscribeChain(ChainBase):
        self.remote_list(channel, userid)

    @staticmethod
-    def __get_subscribe_no_exits(no_exists: Dict[int, Dict[int, NotExistMediaInfo]],
+    def __get_subscribe_no_exits(no_exists: Dict[Union[int, str], Dict[int, NotExistMediaInfo]],
                                 mediakey: Union[str, int],
                                 begin_season: int,
                                 total_episode: int,
--- a/app/chain/system.py
+++ b/app/chain/system.py
@@ -87,7 +87,7 @@ class SystemChain(ChainBase, metaclass=Singleton):
        """
        获取最新版本
        """
-        version_res = RequestUtils(proxies=settings.PROXY).get_res(
+        version_res = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS).get_res(
            "https://api.github.com/repos/jxxghp/MoviePilot/releases/latest")
        if version_res:
            ver_json = version_res.json()
--- a/app/chain/tmdb.py
+++ b/app/chain/tmdb.py
@@ -62,28 +62,28 @@ class TmdbChain(ChainBase, metaclass=Singleton):
        根据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]:
        """
        根据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]:
        """
        根据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]:
        """
        根据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]:
        """
@@ -91,7 +91,7 @@ class TmdbChain(ChainBase, metaclass=Singleton):
        :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]:
        """
@@ -99,14 +99,14 @@ class TmdbChain(ChainBase, metaclass=Singleton):
        :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:
        """
        根据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]:
        """
@@ -114,7 +114,7 @@ class TmdbChain(ChainBase, metaclass=Singleton):
        :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):
--- a/app/chain/torrents.py
+++ b/app/chain/torrents.py
@@ -12,6 +12,7 @@ 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
@@ -34,6 +35,7 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
        self.rsshelper = RssHelper()
        self.systemconfig = SystemConfigOper()
        self.mediachain = MediaChain()
+        self.torrenthelper = TorrentHelper()

    def remote_refresh(self, channel: MessageChannel, userid: Union[str, int] = None):
        """
@@ -60,7 +62,16 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
        else:
            return self.load_cache(self._rss_file) or {}

-    @cached(cache=TTLCache(maxsize=128, ttl=600))
+    def clear_torrents(self):
+        """
+        清理种子缓存数据
+        """
+        logger.info(f'开始清理种子缓存数据 ...')
+        self.remove_cache(self._spider_file)
+        self.remove_cache(self._rss_file)
+        logger.info(f'种子缓存数据清理完成')
+
+    @cached(cache=TTLCache(maxsize=128, ttl=595))
    def browse(self, domain: str) -> List[TorrentInfo]:
        """
        浏览站点首页内容，返回种子清单，TTL缓存10分钟
@@ -73,7 +84,7 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
            return []
        return self.refresh_torrents(site=site)

-    @cached(cache=TTLCache(maxsize=128, ttl=300))
+    @cached(cache=TTLCache(maxsize=128, ttl=295))
    def rss(self, domain: str) -> List[TorrentInfo]:
        """
        获取站点RSS内容，返回种子清单，TTL缓存5分钟
@@ -134,6 +145,11 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
        # 读取缓存
        torrents_cache = self.get_torrents()

+        # 缓存过滤掉无效种子
+        for _domain, _torrents in torrents_cache.items():
+            torrents_cache[_domain] = [_torrent for _torrent in _torrents
+                                       if not self.torrenthelper.is_invalid(_torrent.torrent_info.enclosure)]
+
        # 所有站点索引
        indexers = self.siteshelper.get_indexers()
        # 遍历站点缓存资源
--- a/app/chain/transfer.py
+++ b/app/chain/transfer.py
@@ -259,8 +259,8 @@ class TransferChain(ChainBase):
                    )
                    self.post_message(Notification(
                        mtype=NotificationType.Manual,
-                        title=f"{file_path.name} 未识别到媒体信息，无法入库！\n"
-                              f"回复：```\n/redo {his.id} [tmdbid]|[类型]\n``` 手动识别转移。"
+                        title=f"{file_path.name} 未识别到媒体信息，无法入库！",
+                        text=f"回复：```\n/redo {his.id} [tmdbid]|[类型]\n``` 手动识别转移。"
                    ))
                    # 计数
                    processed_num += 1
@@ -481,6 +481,24 @@ class TransferChain(ChainBase):
                                           text=errmsg, userid=userid))
            return

+    @staticmethod
+    def get_root_path(path: str, type_name: str, category: str) -> Path:
+        """
+        计算媒体库目录的根路径
+        """
+        if not path or path == "None":
+            return None
+        index = -2
+        if type_name != '电影':
+            index = -3
+        if category:
+            index -= 1
+        if '/' in path:
+            retpath = '/'.join(path.split('/')[:index])
+        else:
+            retpath = '\\'.join(path.split('\\')[:index])
+        return Path(retpath)
+
    def re_transfer(self, logid: int, mtype: MediaType = None,
                    mediaid: str = None) -> Tuple[bool, str]:
        """
@@ -498,7 +516,7 @@ class TransferChain(ChainBase):
        src_path = Path(history.src)
        if not src_path.exists():
            return False, f"源目录不存在：{src_path}"
-        dest_path = Path(history.dest) if history.dest else None
+        dest_path = self.get_root_path(path=history.dest, type_name=history.type, category=history.category)
        # 查询媒体信息
        if mtype and mediaid:
            mediainfo = self.recognize_media(mtype=mtype, tmdbid=int(mediaid) if str(mediaid).isdigit() else None,
--- a/app/core/config.py
+++ b/app/core/config.py
@@ -1,7 +1,7 @@
 import secrets
 import sys
 from pathlib import Path
-from typing import List
+from typing import List, Optional

 from pydantic import BaseSettings

@@ -156,7 +156,7 @@ class Settings(BaseSettings):
    # 媒体服务器 emby/jellyfin/plex，多个媒体服务器,分割
    MEDIASERVER: str = "emby"
    # 媒体服务器同步间隔（小时）
-    MEDIASERVER_SYNC_INTERVAL: int = 6
+    MEDIASERVER_SYNC_INTERVAL: Optional[int] = 6
    # 媒体服务器同步黑名单，多个媒体库名称,分割
    MEDIASERVER_SYNC_BLACKLIST: str = None
    # EMBY服务器地址，IP:PORT
@@ -180,18 +180,18 @@ class Settings(BaseSettings):
    # CookieCloud端对端加密密码
    COOKIECLOUD_PASSWORD: str = None
    # CookieCloud同步间隔（分钟）
-    COOKIECLOUD_INTERVAL: int = 60 * 24
+    COOKIECLOUD_INTERVAL: Optional[int] = 60 * 24
    # OCR服务器地址
    OCR_HOST: str = "https://movie-pilot.org"
    # 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_MOVIE_NAME: str = "电影"
+    # 电视剧媒体库目录名
+    LIBRARY_TV_NAME: str = "电视剧"
+    # 动漫媒体库目录名，不设置时使用电视剧目录
    LIBRARY_ANIME_NAME: str = None
    # 二级分类
    LIBRARY_CATEGORY: bool = True
@@ -211,7 +211,11 @@ class Settings(BaseSettings):
    # 大内存模式
    BIG_MEMORY_MODE: bool = False
    # 插件市场仓库地址，多个地址使用,分隔，地址以/结尾
-    PLUGIN_MARKET: str = "https://raw.githubusercontent.com/jxxghp/MoviePilot-Plugins/main/"
+    PLUGIN_MARKET: str = "https://github.com/jxxghp/MoviePilot-Plugins"
+    # Github token，提高请求api限流阈值 ghp_****
+    GITHUB_TOKEN: str = None
+    # 自动检查和更新站点资源包（站点索引、认证等）
+    AUTO_UPDATE_RESOURCE: bool = True

    @property
    def INNER_CONFIG_PATH(self):
@@ -321,6 +325,17 @@ class Settings(BaseSettings):
            return Path(self.DOWNLOAD_ANIME_PATH)
        return self.SAVE_TV_PATH

+    @property
+    def GITHUB_HEADERS(self):
+        """
+        Github请求头
+        """
+        if self.GITHUB_TOKEN:
+            return {
+                "Authorization": f"Bearer {self.GITHUB_TOKEN}"
+            }
+        return {}
+
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        with self.CONFIG_PATH as p:
--- a/app/core/context.py
+++ b/app/core/context.py
@@ -495,6 +495,18 @@ class MediaInfo:
            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):
--- a/app/core/meta/metavideo.py
+++ b/app/core/meta/metavideo.py
@@ -34,6 +34,7 @@ class MetaVideo(MetaBase):
    _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]+季" \
@@ -182,8 +183,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:
--- a/app/core/metainfo.py
+++ b/app/core/metainfo.py
@@ -120,7 +120,7 @@ def find_metainfo(title: str) -> Tuple[str, dict]:
        if doubanid and doubanid[0].isdigit():
            metainfo['doubanid'] = doubanid[0]
        # 查找媒体类型
-        mtype = re.findall(r'(?<=type=)\d+', result)
+        mtype = re.findall(r'(?<=type=)\w+', result)
        if mtype:
            match mtype[0]:
                case "movie":
--- a/app/core/plugin.py
+++ b/app/core/plugin.py
@@ -12,6 +12,7 @@ from app.schemas.types import SystemConfigKey
 from app.utils.object import ObjectUtils
 from app.utils.singleton import Singleton
 from app.utils.string import StringUtils
+from app.utils.system import SystemUtils


 class PluginManager(metaclass=Singleton):
@@ -105,6 +106,8 @@ class PluginManager(metaclass=Singleton):
        """
        安装本地不存在的在线插件
        """
+        if SystemUtils.is_frozen():
+            return
        logger.info("开始安装在线插件...")
        # 已安装插件
        install_plugins = self.systemconfig.get(SystemConfigKey.UserInstalledPlugins) or []
@@ -144,6 +147,14 @@ class PluginManager(metaclass=Singleton):
            return False
        return self.systemconfig.set(self._config_key % pid, conf)

+    def delete_plugin_config(self, pid: str) -> bool:
+        """
+        删除插件配置
+        """
+        if not self._plugins.get(pid):
+            return False
+        return self.systemconfig.delete(self._config_key % pid)
+
    def get_plugin_form(self, pid: str) -> Tuple[List[dict], Dict[str, Any]]:
        """
        获取插件表单
@@ -285,9 +296,6 @@ class PluginManager(metaclass=Singleton):
                # 图标
                if plugin.get("icon"):
                    conf.update({"plugin_icon": plugin.get("icon")})
-                # 主题色
-                if plugin.get("color"):
-                    conf.update({"plugin_color": plugin.get("color")})
                # 作者
                if plugin.get("author"):
                    conf.update({"plugin_author": plugin.get("author")})
@@ -355,9 +363,6 @@ class PluginManager(metaclass=Singleton):
            # 图标
            if hasattr(plugin, "plugin_icon"):
                conf.update({"plugin_icon": plugin.plugin_icon})
-            # 主题色
-            if hasattr(plugin, "plugin_color"):
-                conf.update({"plugin_color": plugin.plugin_color})
            # 作者
            if hasattr(plugin, "plugin_author"):
                conf.update({"plugin_author": plugin.plugin_author})
--- a/app/db/init.py
+++ b/app/db/init.py
@@ -1,7 +1,10 @@
+from typing import Any, Self, List
 from typing import Tuple, Optional, Generator

 from sqlalchemy import create_engine, QueuePool
-from sqlalchemy.orm import sessionmaker, Session, scoped_session
+from sqlalchemy import inspect
+from sqlalchemy.orm import declared_attr
+from sqlalchemy.orm import sessionmaker, Session, scoped_session, as_declarative

 from app.core.config import settings

@@ -135,6 +138,52 @@ def db_query(func):
    return wrapper


+@as_declarative()
+class Base:
+    id: Any
+    __name__: str
+
+    @db_update
+    def create(self, db: Session):
+        db.add(self)
+
+    @classmethod
+    @db_query
+    def get(cls, db: Session, rid: int) -> Self:
+        return db.query(cls).filter(cls.id == rid).first()
+
+    @db_update
+    def update(self, db: Session, payload: dict):
+        payload = {k: v for k, v in payload.items() if v is not None}
+        for key, value in payload.items():
+            setattr(self, key, value)
+        if inspect(self).detached:
+            db.add(self)
+
+    @classmethod
+    @db_update
+    def delete(cls, db: Session, rid):
+        db.query(cls).filter(cls.id == rid).delete()
+
+    @classmethod
+    @db_update
+    def truncate(cls, db: Session):
+        db.query(cls).delete()
+
+    @classmethod
+    @db_query
+    def list(cls, db: Session) -> List[Self]:
+        result = db.query(cls).all()
+        return list(result)
+
+    def to_dict(self):
+        return {c.name: getattr(self, c.name, None) for c in self.__table__.columns}
+
+    @declared_attr
+    def __tablename__(self) -> str:
+        return self.__name__.lower()
+
+
 class DbOper:
    """
    数据库操作基类
--- a/app/db/downloadhistory_oper.py
+++ b/app/db/downloadhistory_oper.py
@@ -57,7 +57,14 @@ class DownloadHistoryOper(DbOper):
        按fullpath查询下载文件记录
        :param fullpath: 数据key
        """
-        return DownloadFiles.get_by_fullpath(self._db, fullpath)
+        return DownloadFiles.get_by_fullpath(self._db, fullpath=fullpath, all_files=False)
+
+    def get_files_by_fullpath(self, fullpath: str) -> List[DownloadFiles]:
+        """
+        按fullpath查询下载文件记录
+        :param fullpath: 数据key
+        """
+        return DownloadFiles.get_by_fullpath(self._db, fullpath=fullpath, all_files=True)

    def get_files_by_savepath(self, fullpath: str) -> List[DownloadFiles]:
        """
@@ -78,7 +85,7 @@ class DownloadHistoryOper(DbOper):
        按fullpath查询下载文件记录hash
        :param fullpath: 数据key
        """
-        fileinfo: DownloadFiles = DownloadFiles.get_by_fullpath(self._db, fullpath)
+        fileinfo: DownloadFiles = DownloadFiles.get_by_fullpath(self._db, fullpath=fullpath, all_files=False)
        if fileinfo:
            return fileinfo.download_hash
        return ""
@@ -115,3 +122,13 @@ class DownloadHistoryOper(DbOper):
        return DownloadHistory.list_by_user_date(db=self._db,
                                                 date=date,
                                                 username=username)
+
+    def list_by_date(self, date: str, type: str, tmdbid: str, seasons: str = None) -> List[DownloadHistory]:
+        """
+        查询某时间之后的下载历史
+        """
+        return DownloadHistory.list_by_date(db=self._db,
+                                            date=date,
+                                            type=type,
+                                            tmdbid=tmdbid,
+                                            seasons=seasons)
--- a/app/db/init.py
+++ b/app/db/init.py
@@ -1,14 +1,10 @@
-import importlib
-from pathlib import Path
-
 from alembic.command import upgrade
 from alembic.config import Config

 from app.core.config import settings
 from app.core.security import get_password_hash
-from app.db import Engine, SessionFactory
-from app.db.models import Base
-from app.db.models.user import User
+from app.db import Engine, SessionFactory, Base
+from app.db.models import *
 from app.log import logger


@@ -16,21 +12,18 @@ def init_db():
    """
    初始化数据库
    """
-    # 导入模块，避免建表缺失
-    for module in Path(__file__).with_name("models").glob("*.py"):
-        importlib.import_module(f"app.db.models.{module.stem}")
    # 全量建表
    Base.metadata.create_all(bind=Engine)
    # 初始化超级管理员
    with SessionFactory() as db:
-        user = User.get_by_name(db=db, name=settings.SUPERUSER)
-        if not user:
-            user = User(
+        _user = User.get_by_name(db=db, name=settings.SUPERUSER)
+        if not _user:
+            _user = User(
                name=settings.SUPERUSER,
                hashed_password=get_password_hash(settings.SUPERUSER_PASSWORD),
                is_superuser=True,
            )
-            user.create(db)
+            _user.create(db)


 def update_db():
--- a/app/db/mediaserver_oper.py
+++ b/app/db/mediaserver_oper.py
@@ -25,7 +25,7 @@ class MediaServerOper(DbOper):
            return True
        return False

-    def empty(self, server: str):
+    def empty(self, server: Optional[str] = None):
        """
        清空媒体服务器数据
        """
--- a/app/db/models/init.py
+++ b/app/db/models/init.py
@@ -1,52 +1,9 @@
-from typing import Any, Self, List
-
-from sqlalchemy import inspect
-from sqlalchemy.orm import as_declarative, declared_attr, Session
-
-from app.db import db_update, db_query
-
-
-@as_declarative()
-class Base:
-    id: Any
-    __name__: str
-
-    @db_update
-    def create(self, db: Session):
-        db.add(self)
-
-    @classmethod
-    @db_query
-    def get(cls, db: Session, rid: int) -> Self:
-        return db.query(cls).filter(cls.id == rid).first()
-
-    @db_update
-    def update(self, db: Session, payload: dict):
-        payload = {k: v for k, v in payload.items() if v is not None}
-        for key, value in payload.items():
-            setattr(self, key, value)
-        if inspect(self).detached:
-            db.add(self)
-
-    @classmethod
-    @db_update
-    def delete(cls, db: Session, rid):
-        db.query(cls).filter(cls.id == rid).delete()
-
-    @classmethod
-    @db_update
-    def truncate(cls, db: Session):
-        db.query(cls).delete()
-
-    @classmethod
-    @db_query
-    def list(cls, db: Session) -> List[Self]:
-        result = db.query(cls).all()
-        return list(result)
-
-    def to_dict(self):
-        return {c.name: getattr(self, c.name, None) for c in self.__table__.columns}
-
-    @declared_attr
-    def __tablename__(self) -> str:
-        return self.__name__.lower()
+from .downloadhistory import DownloadHistory, DownloadFiles
+from .mediaserver import MediaServerItem
+from .plugindata import PluginData
+from .site import Site
+from .siteicon import SiteIcon
+from .subscribe import Subscribe
+from .systemconfig import SystemConfig
+from .transferhistory import TransferHistory
+from .user import User
--- a/app/db/models/downloadhistory.py
+++ b/app/db/models/downloadhistory.py
@@ -1,8 +1,7 @@
 from sqlalchemy import Column, Integer, String, Sequence
 from sqlalchemy.orm import Session

-from app.db import db_query
-from app.db.models import Base, db_update
+from app.db import db_query, db_update, Base


 class DownloadHistory(Base):
@@ -123,6 +122,24 @@ class DownloadHistory(Base):
                DownloadHistory.id.desc()).all()
        return list(result)

+    @staticmethod
+    @db_query
+    def list_by_date(db: Session, date: str, type: str, tmdbid: str, seasons: str = None):
+        """
+        查询某时间之后的下载历史
+        """
+        if seasons:
+            return db.query(DownloadHistory).filter(DownloadHistory.date > date,
+                                                    DownloadHistory.type == type,
+                                                    DownloadHistory.tmdbid == tmdbid,
+                                                    DownloadHistory.seasons == seasons).order_by(
+                DownloadHistory.id.desc()).all()
+        else:
+            return db.query(DownloadHistory).filter(DownloadHistory.date > date,
+                                                    DownloadHistory.type == type,
+                                                    DownloadHistory.tmdbid == tmdbid).order_by(
+                DownloadHistory.id.desc()).all()
+

 class DownloadFiles(Base):
    """
@@ -157,9 +174,13 @@ class DownloadFiles(Base):

    @staticmethod
    @db_query
-    def get_by_fullpath(db: Session, fullpath: str):
-        return db.query(DownloadFiles).filter(DownloadFiles.fullpath == fullpath).order_by(
-            DownloadFiles.id.desc()).first()
+    def get_by_fullpath(db: Session, fullpath: str, all_files: bool = False):
+        if not all_files:
+            return db.query(DownloadFiles).filter(DownloadFiles.fullpath == fullpath).order_by(
+                DownloadFiles.id.desc()).first()
+        else:
+            return db.query(DownloadFiles).filter(DownloadFiles.fullpath == fullpath).order_by(
+                DownloadFiles.id.desc()).all()

    @staticmethod
    @db_query
--- a/app/db/models/mediaserver.py
+++ b/app/db/models/mediaserver.py
@@ -1,15 +1,15 @@
 from datetime import datetime
+from typing import Optional

 from sqlalchemy import Column, Integer, String, Sequence
 from sqlalchemy.orm import Session

-from app.db import db_query
-from app.db.models import Base, db_update
+from app.db import db_query, db_update, Base


 class MediaServerItem(Base):
    """
-    站点表
+    媒体服务器媒体条目表
    """
    id = Column(Integer, Sequence('id'), primary_key=True, index=True)
    # 服务器类型
@@ -48,8 +48,11 @@ class MediaServerItem(Base):

    @staticmethod
    @db_update
-    def empty(db: Session, server: str):
-        db.query(MediaServerItem).filter(MediaServerItem.server == server).delete()
+    def empty(db: Session, server: Optional[str] = None):
+        if server is None:
+            db.query(MediaServerItem).delete()
+        else:
+            db.query(MediaServerItem).filter(MediaServerItem.server == server).delete()

    @staticmethod
    @db_query
--- a/app/db/models/plugindata.py
+++ b/app/db/models/plugindata.py
@@ -1,8 +1,7 @@
 from sqlalchemy import Column, Integer, String, Sequence
 from sqlalchemy.orm import Session

-from app.db import db_query
-from app.db.models import Base, db_update
+from app.db import db_query, db_update, Base


 class PluginData(Base):
--- a/app/db/models/site.py
+++ b/app/db/models/site.py
@@ -3,8 +3,7 @@ from datetime import datetime
 from sqlalchemy import Boolean, Column, Integer, String, Sequence
 from sqlalchemy.orm import Session

-from app.db import db_query
-from app.db.models import Base, db_update
+from app.db import db_query, db_update, Base


 class Site(Base):
--- a/app/db/models/siteicon.py
+++ b/app/db/models/siteicon.py
@@ -1,8 +1,7 @@
 from sqlalchemy import Column, Integer, String, Sequence
 from sqlalchemy.orm import Session

-from app.db import db_query
-from app.db.models import Base
+from app.db import db_query, Base


 class SiteIcon(Base):
--- a/app/db/models/subscribe.py
+++ b/app/db/models/subscribe.py
@@ -1,8 +1,7 @@
 from sqlalchemy import Column, Integer, String, Sequence
 from sqlalchemy.orm import Session

-from app.db import db_update, db_query
-from app.db.models import Base
+from app.db import db_query, db_update, Base


 class Subscribe(Base):
@@ -66,6 +65,8 @@ class Subscribe(Base):
    best_version = Column(Integer, default=0)
    # 当前优先级
    current_priority = Column(Integer)
+    # 保存路径
+    save_path = Column(String)

    @staticmethod
    @db_query
@@ -97,7 +98,10 @@ class Subscribe(Base):

    @staticmethod
    @db_query
-    def get_by_title(db: Session, title: str):
+    def get_by_title(db: Session, title: str, season: int = None):
+        if season:
+            return db.query(Subscribe).filter(Subscribe.name == title,
+                                              Subscribe.season == season).first()
        return db.query(Subscribe).filter(Subscribe.name == title).first()

    @staticmethod
--- a/app/db/models/systemconfig.py
+++ b/app/db/models/systemconfig.py
@@ -1,8 +1,7 @@
 from sqlalchemy import Column, Integer, String, Sequence
 from sqlalchemy.orm import Session

-from app.db import db_update, db_query
-from app.db.models import Base
+from app.db import db_query, db_update, Base


 class SystemConfig(Base):
--- a/app/db/models/transferhistory.py
+++ b/app/db/models/transferhistory.py
@@ -3,8 +3,7 @@ import time
 from sqlalchemy import Column, Integer, String, Sequence, Boolean, func
 from sqlalchemy.orm import Session

-from app.db import db_query
-from app.db.models import Base, db_update
+from app.db import db_query, db_update, Base


 class TransferHistory(Base):
--- a/app/db/models/user.py
+++ b/app/db/models/user.py
@@ -2,8 +2,7 @@ from sqlalchemy import Boolean, Column, Integer, String, Sequence
 from sqlalchemy.orm import Session

 from app.core.security import verify_password
-from app.db import db_update, db_query
-from app.db.models import Base
+from app.db import db_query, db_update, Base


 class User(Base):
--- a/app/db/plugindata_oper.py
+++ b/app/db/plugindata_oper.py
@@ -2,7 +2,7 @@ import json
 from typing import Any

 from app.db import DbOper
-from app.db.models.plugin import PluginData
+from app.db.models.plugindata import PluginData
 from app.utils.object import ObjectUtils


--- a/app/db/systemconfig_oper.py
+++ b/app/db/systemconfig_oper.py
@@ -56,6 +56,20 @@ class SystemConfigOper(DbOper, metaclass=Singleton):
            return self.__SYSTEMCONF
        return self.__SYSTEMCONF.get(key)

+    def delete(self, key: Union[str, SystemConfigKey]):
+        """
+        删除系统设置
+        """
+        if isinstance(key, SystemConfigKey):
+            key = key.value
+        # 更新内存
+        self.__SYSTEMCONF.pop(key, None)
+        # 写入数据库
+        conf = SystemConfig.get_by_key(self._db, key)
+        if conf:
+            conf.delete(self._db, conf.id)
+        return True
+
    def __del__(self):
        if self._db:
            self._db.close()
--- a/app/helper/module.py
+++ b/app/helper/module.py
@@ -1,6 +1,7 @@
 # -*- coding: utf-8 -*-
 import importlib
 import pkgutil
+from pathlib import Path


 class ModuleHelper:
@@ -35,3 +36,17 @@ class ModuleHelper:
                print(f'加载模块 {package_name} 失败：{err}')

        return submodules
+
+    @staticmethod
+    def dynamic_import_all_modules(base_path: Path, package_name: str):
+        """
+        动态导入目录下所有模块
+        """
+        modules = []
+        # 遍历文件夹，找到所有模块文件
+        for file in base_path.glob("*.py"):
+            file_name = file.stem
+            if file_name != "__init__":
+                modules.append(file_name)
+                full_module_name = f"{package_name}.{file_name}"
+                importlib.import_module(full_module_name)
--- a/app/helper/plugin.py
+++ b/app/helper/plugin.py
@@ -16,6 +16,8 @@ class PluginHelper(metaclass=Singleton):
    插件市场管理，下载安装插件到本地
    """

+    _base_url = "https://raw.githubusercontent.com/%s/%s/main/"
+
    @cached(cache=TTLCache(maxsize=10, ttl=1800))
    def get_plugins(self, repo_url: str) -> Dict[str, dict]:
        """
@@ -24,32 +26,53 @@ class PluginHelper(metaclass=Singleton):
        """
        if not repo_url:
            return {}
-        res = RequestUtils(proxies=settings.PROXY, timeout=10).get_res(f"{repo_url}package.json")
+        user, repo = self.get_repo_info(repo_url)
+        if not user or not repo:
+            return {}
+        raw_url = self._base_url % (user, repo)
+        res = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS,
+                           timeout=10).get_res(f"{raw_url}package.json")
        if res:
            return json.loads(res.text)
        return {}

    @staticmethod
-    def install(pid: str, repo_url: str) -> Tuple[bool, str]:
+    def get_repo_info(repo_url: str) -> Tuple[Optional[str], Optional[str]]:
        """
-        安装插件
+        获取Github仓库信息
+        :param repo_url: Github仓库地址
        """
-        # 从Github的repo_url获取用户和项目名
+        if not repo_url:
+            return None, None
+        if not repo_url.endswith("/"):
+            repo_url += "/"
+        if repo_url.count("/") < 6:
+            repo_url = f"{repo_url}main/"
        try:
            user, repo = repo_url.split("/")[-4:-2]
        except Exception as e:
-            return False, f"不支持的插件仓库地址格式：{str(e)}"
-        if not user or not repo:
-            return False, "不支持的插件仓库地址格式"
+            print(str(e))
+            return None, None
+        return user, repo
+
+    def install(self, pid: str, repo_url: str) -> Tuple[bool, str]:
+        """
+        安装插件
+        """
        if SystemUtils.is_frozen():
            return False, "可执行文件模式下，只能安装本地插件"

+        # 从Github的repo_url获取用户和项目名
+        user, repo = self.get_repo_info(repo_url)
+        if not user or not repo:
+            return False, "不支持的插件仓库地址格式"
+
        def __get_filelist(_p: str) -> Tuple[Optional[list], Optional[str]]:
            """
            获取插件的文件列表
            """
            file_api = f"https://api.github.com/repos/{user}/{repo}/contents/plugins/{_p.lower()}"
-            r = RequestUtils(proxies=settings.PROXY).get_res(file_api)
+            r = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS, timeout=30).get_res(file_api)
            if not r or r.status_code != 200:
                return None, f"连接仓库失败：{r.status_code} - {r.reason}"
            ret = r.json()
@@ -66,7 +89,8 @@ class PluginHelper(metaclass=Singleton):
            for item in _l:
                if item.get("download_url"):
                    # 下载插件文件
-                    res = RequestUtils(proxies=settings.PROXY).get_res(item["download_url"])
+                    res = RequestUtils(proxies=settings.PROXY,
+                                       headers=settings.GITHUB_HEADERS, timeout=60).get_res(item["download_url"])
                    if not res:
                        return False, f"文件 {item.get('name')} 下载失败！"
                    elif res.status_code != 200:
@@ -83,7 +107,7 @@ class PluginHelper(metaclass=Singleton):
                    l, m = __get_filelist(p)
                    if not l:
                        return False, m
-                    return __download_files(p, l)
+                    __download_files(p, l)
            return True, ""

        if not pid or not repo_url:
--- a/app/helper/resource.py
+++ b/app/helper/resource.py
@@ -0,0 +1,103 @@
+import json
+from pathlib import Path
+
+from app.core.config import settings
+from app.helper.sites import SitesHelper
+from app.log import logger
+from app.utils.http import RequestUtils
+from app.utils.singleton import Singleton
+from app.utils.string import StringUtils
+from app.utils.system import SystemUtils
+
+
+class ResourceHelper(metaclass=Singleton):
+    """
+    检测和更新资源包
+    """
+    # 资源包的git仓库地址
+    _repo = "https://raw.githubusercontent.com/jxxghp/MoviePilot-Resources/main/package.json"
+    _files_api = f"https://api.github.com/repos/jxxghp/MoviePilot-Resources/contents/resources"
+    _base_dir: Path = settings.ROOT_PATH
+
+    def __init__(self):
+        self.siteshelper = SitesHelper()
+        self.check()
+
+    def check(self):
+        """
+        检测是否有更新，如有则下载安装
+        """
+        if not settings.AUTO_UPDATE_RESOURCE:
+            return
+        if SystemUtils.is_frozen():
+            return
+        logger.info("开始检测资源包版本...")
+        res = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS, timeout=10).get_res(self._repo)
+        if res:
+            resource_info = json.loads(res.text)
+        else:
+            logger.warn("无法连接资源包仓库！")
+            return
+        online_version = resource_info.get("version")
+        if online_version:
+            logger.info(f"最新资源包版本：v{online_version}")
+        # 需要更新的资源包
+        need_updates = {}
+        # 资源明细
+        resources: dict = resource_info.get("resources") or {}
+        for rname, resource in resources.items():
+            rtype = resource.get("type")
+            platform = resource.get("platform")
+            target = resource.get("target")
+            version = resource.get("version")
+            # 判断平台
+            if platform and platform != SystemUtils.platform:
+                continue
+            # 判断本地是否存在
+            local_path = self._base_dir / target / rname
+            if not local_path.exists():
+                continue
+            # 判断版本号
+            if rtype == "auth":
+                # 站点认证资源
+                local_version = self.siteshelper.auth_version
+            elif rtype == "sites":
+                # 站点索引资源
+                local_version = self.siteshelper.indexer_version
+            else:
+                continue
+            if StringUtils.compare_version(version, local_version) > 0:
+                logger.info(f"{rname} 资源包有更新，最新版本：v{version}")
+            else:
+                continue
+            # 需要安装
+            need_updates[rname] = target
+        if need_updates:
+            # 下载文件信息列表
+            r = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS,
+                             timeout=30).get_res(self._files_api)
+            if not r or r.status_code != 200:
+                return None, f"连接仓库失败：{r.status_code} - {r.reason}"
+            files_info = r.json()
+            for item in files_info:
+                save_path = need_updates.get(item.get("name"))
+                if not save_path:
+                    continue
+                if item.get("download_url"):
+                    # 下载资源文件
+                    res = RequestUtils(proxies=settings.PROXY, headers=settings.GITHUB_HEADERS,
+                                       timeout=180).get_res(item["download_url"])
+                    if not res:
+                        logger.error(f"文件 {item.get('name')} 下载失败！")
+                    elif res.status_code != 200:
+                        logger.error(f"下载文件 {item.get('name')} 失败：{res.status_code} - {res.reason}")
+                    # 创建插件文件夹
+                    file_path = self._base_dir / save_path / item.get("name")
+                    if not file_path.parent.exists():
+                        file_path.parent.mkdir(parents=True, exist_ok=True)
+                    # 写入文件
+                    file_path.write_bytes(res.content)
+            logger.info("资源包更新完成，开始重启服务...")
+            SystemUtils.restart()
+        else:
+            logger.info("所有资源已最新，无需更新")
--- a/app/helper/rss.py
+++ b/app/helper/rss.py
@@ -1,11 +1,14 @@
+import re
 import xml.dom.minidom
 from typing import List, Tuple, Union
 from urllib.parse import urljoin

+import chardet
 from lxml import etree

 from app.core.config import settings
 from app.helper.browser import PlaywrightHelper
+from app.log import logger
 from app.utils.dom import DomUtils
 from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
@@ -240,8 +243,28 @@ class RssHelper:
            print(str(err))
            return []
        if ret:
-            ret_xml = ret.text
+            ret_xml = ""
            try:
+                # 使用chardet检测字符编码
+                raw_data = ret.content
+                if raw_data:
+                    try:
+                        result = chardet.detect(raw_data)
+                        encoding = result['encoding']
+                        # 解码为字符串
+                        ret_xml = raw_data.decode(encoding)
+                    except Exception as e:
+                        logger.debug(f"chardet解码失败：{str(e)}")
+                        # 探测utf-8解码
+                        match = re.search(r'encoding\s*=\s*["\']([^"\']+)["\']', ret.text)
+                        if match:
+                            encoding = match.group(1)
+                            if encoding:
+                                ret_xml = raw_data.decode(encoding)
+                        else:
+                            ret.encoding = ret.apparent_encoding
+                if not ret_xml:
+                    ret_xml = ret.text
                # 解析XML
                dom_tree = xml.dom.minidom.parseString(ret_xml)
                rootNode = dom_tree.documentElement
--- a/app/helper/torrent.py
+++ b/app/helper/torrent.py
@@ -14,13 +14,17 @@ from app.db.systemconfig_oper import SystemConfigOper
 from app.log import logger
 from app.utils.http import RequestUtils
 from app.schemas.types import MediaType, SystemConfigKey
+from app.utils.singleton import Singleton


-class TorrentHelper:
+class TorrentHelper(metaclass=Singleton):
    """
    种子帮助类
    """

+    # 失败的种子：站点链接
+    _invalid_torrents = []
+
    def __init__(self):
        self.system_config = SystemConfigOper()

@@ -123,6 +127,8 @@ class TorrentHelper:
        elif req.status_code == 429:
            return None, None, "", [], "触发站点流控，请稍后重试"
        else:
+            # 把错误的种子记下来，避免重复使用
+            self.add_invalid(url)
            return None, None, "", [], f"下载种子出错，状态码：{req.status_code}"

    @staticmethod
@@ -276,3 +282,16 @@ class TorrentHelper:
                continue
            episodes = list(set(episodes).union(set(meta.episode_list)))
        return episodes
+
+    def is_invalid(self, url: str) -> bool:
+        """
+        判断种子是否是无效种子
+        """
+        return url in self._invalid_torrents
+
+    def add_invalid(self, url: str):
+        """
+        添加无效种子
+        """
+        if url not in self._invalid_torrents:
+            self._invalid_torrents.append(url)
--- a/app/main.py
+++ b/app/main.py
@@ -22,10 +22,12 @@ from app.core.plugin import PluginManager
 from app.db.init import init_db, update_db
 from app.helper.thread import ThreadHelper
 from app.helper.display import DisplayHelper
+from app.helper.resource import ResourceHelper
 from app.helper.sites import SitesHelper
 from app.scheduler import Scheduler
 from app.command import Command

+
 # App
 App = FastAPI(title=settings.PROJECT_NAME,
              openapi_url=f"{settings.API_V1_STR}/openapi.json")
@@ -60,7 +62,9 @@ def start_frontend():
    """
    启动前端服务
    """
-    if not SystemUtils.is_frozen():
+    # 仅Windows可执行文件支持内嵌nginx
+    if not SystemUtils.is_frozen() \
+            or not SystemUtils.is_windows():
        return
    # 临时Nginx目录
    nginx_path = settings.ROOT_PATH / 'nginx'
@@ -73,27 +77,20 @@ def start_frontend():
        SystemUtils.move(nginx_path, run_nginx_dir)
    # 启动Nginx
    import subprocess
-    if SystemUtils.is_windows():
-        subprocess.Popen("start nginx.exe",
-                         cwd=run_nginx_dir,
-                         shell=True)
-    else:
-        subprocess.Popen("nohup ./nginx &",
-                         cwd=run_nginx_dir,
-                         shell=True)
+    subprocess.Popen("start nginx.exe",
+                     cwd=run_nginx_dir,
+                     shell=True)


 def stop_frontend():
    """
    停止前端服务
    """
-    if not SystemUtils.is_frozen():
+    if not SystemUtils.is_frozen() \
+            or not SystemUtils.is_windows():
        return
    import subprocess
-    if SystemUtils.is_windows():
-        subprocess.Popen(f"taskkill /f /im nginx.exe", shell=True)
-    else:
-        subprocess.Popen(f"killall nginx", shell=True)
+    subprocess.Popen(f"taskkill /f /im nginx.exe", shell=True)


 def start_tray():
@@ -104,6 +101,9 @@ def start_tray():
    if not SystemUtils.is_frozen():
        return

+    if not SystemUtils.is_windows():
+        return
+
    def open_web():
        """
        调用浏览器打开前端页面
@@ -169,6 +169,8 @@ def start_module():
    DisplayHelper()
    # 站点管理
    SitesHelper()
+    # 资源包检测
+    ResourceHelper()
    # 加载模块
    ModuleManager()
    # 加载插件
--- a/app/modules/douban/init.py
+++ b/app/modules/douban/init.py
@@ -561,7 +561,7 @@ class DoubanModule(_ModuleBase):
                continue
            if mtype and mtype.value != type_name:
                continue
-            if mtype == MediaType.TV and not season:
+            if mtype and mtype == MediaType.TV and not season:
                season = 1
            item = item_obj.get("target")
            title = item.get("title")
@@ -618,10 +618,17 @@ class DoubanModule(_ModuleBase):
            else:
                doubaninfo = self.douban_info(doubanid=mediainfo.douban_id,
                                              mtype=mediainfo.type)
+            if not doubaninfo:
+                logger(f"未获取到 {mediainfo.douban_id} 的豆瓣媒体信息，无法刮削！")
+                return
+            # 豆瓣媒体信息
+            mediainfo = MediaInfo(douban_info=doubaninfo)
+            # 补充图片
+            self.obtain_images(mediainfo)
            # 刮削路径
            scrape_path = path / path.name
            self.scraper.gen_scraper_files(meta=meta,
-                                           mediainfo=MediaInfo(douban_info=doubaninfo),
+                                           mediainfo=mediainfo,
                                           file_path=scrape_path,
                                           transfer_type=transfer_type)
        else:
@@ -649,18 +656,102 @@ class DoubanModule(_ModuleBase):
                    else:
                        doubaninfo = self.douban_info(doubanid=mediainfo.douban_id,
                                                      mtype=mediainfo.type)
+                    if not doubaninfo:
+                        logger(f"未获取到 {mediainfo.douban_id} 的豆瓣媒体信息，无法刮削！")
+                        continue
+                    # 豆瓣媒体信息
+                    mediainfo = MediaInfo(douban_info=doubaninfo)
+                    # 补充图片
+                    self.obtain_images(mediainfo)
                    # 刮削
                    self.scraper.gen_scraper_files(meta=meta,
-                                                   mediainfo=MediaInfo(douban_info=doubaninfo),
+                                                   mediainfo=mediainfo,
                                                   file_path=file,
                                                   transfer_type=transfer_type)
                except Exception as e:
                    logger.error(f"刮削文件 {file} 失败，原因：{str(e)}")
        logger.info(f"{path} 刮削完成")

+    def obtain_images(self, mediainfo: MediaInfo) -> Optional[MediaInfo]:
+        """
+        补充抓取媒体信息图片
+        :param mediainfo:  识别的媒体信息
+        :return: 更新后的媒体信息
+        """
+        if settings.RECOGNIZE_SOURCE != "douban":
+            return None
+        if not mediainfo.douban_id:
+            return None
+        if mediainfo.backdrop_path:
+            # 没有图片缺失
+            return mediainfo
+        # 调用图片接口
+        if not mediainfo.backdrop_path:
+            if mediainfo.type == MediaType.MOVIE:
+                info = self.doubanapi.movie_photos(mediainfo.douban_id)
+            else:
+                info = self.doubanapi.tv_photos(mediainfo.douban_id)
+            if not info:
+                return mediainfo
+            images = info.get("photos")
+            # 背景图
+            if images:
+                backdrop = images[0].get("image", {}).get("large") or {}
+                if backdrop:
+                    mediainfo.backdrop_path = backdrop.get("url")
+        return mediainfo
+
    def clear_cache(self):
        """
        清除缓存
        """
+        logger.info("开始清除豆瓣缓存 ...")
        self.doubanapi.clear_cache()
        self.cache.clear()
+        logger.info("豆瓣缓存清除完成")
+
+    def douban_movie_credits(self, doubanid: str, page: int = 1, count: int = 20) -> List[dict]:
+        """
+        根据TMDBID查询电影演职员表
+        :param doubanid:  豆瓣ID
+        :param page:  页码
+        :param count:  数量
+        """
+        result = self.doubanapi.movie_celebrities(subject_id=doubanid)
+        if not result:
+            return []
+        ret_list = result.get("actors") or []
+        if ret_list:
+            return ret_list[(page - 1) * count: page * count]
+        else:
+            return []
+
+    def douban_tv_credits(self, doubanid: str, page: int = 1, count: int = 20) -> List[dict]:
+        """
+        根据TMDBID查询电视剧演职员表
+        :param doubanid:  豆瓣ID
+        :param page:  页码
+        :param count:  数量
+        """
+        result = self.doubanapi.tv_celebrities(subject_id=doubanid)
+        if not result:
+            return []
+        ret_list = result.get("actors") or []
+        if ret_list:
+            return ret_list[(page - 1) * count: page * count]
+        else:
+            return []
+
+    def douban_movie_recommend(self, doubanid: str) -> List[dict]:
+        """
+        根据豆瓣ID查询推荐电影
+        :param doubanid:  豆瓣ID
+        """
+        return self.doubanapi.movie_recommendations(subject_id=doubanid) or []
+
+    def douban_tv_recommend(self, doubanid: str) -> List[dict]:
+        """
+        根据豆瓣ID查询推荐电视剧
+        :param doubanid:  豆瓣ID
+        """
+        return self.doubanapi.tv_recommendations(subject_id=doubanid) or []
--- a/app/modules/douban/apiv2.py
+++ b/app/modules/douban/apiv2.py
@@ -427,6 +427,54 @@ class DoubanApi(metaclass=Singleton):
        return self.__invoke(self._urls["doulist_items"] % subject_id,
                             start=start, count=count, _ts=ts)

+    def movie_recommendations(self, subject_id: str, start: int = 0, count: int = 20,
+                              ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        """
+        电影推荐
+        :param subject_id: 电影id
+        :param start: 开始
+        :param count: 数量
+        :param ts: 时间戳
+        """
+        return self.__invoke(self._urls["movie_recommendations"] % subject_id,
+                             start=start, count=count, _ts=ts)
+
+    def tv_recommendations(self, subject_id: str, start: int = 0, count: int = 20,
+                           ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        """
+        电视剧推荐
+        :param subject_id: 电视剧id
+        :param start: 开始
+        :param count: 数量
+        :param ts: 时间戳
+        """
+        return self.__invoke(self._urls["tv_recommendations"] % subject_id,
+                             start=start, count=count, _ts=ts)
+
+    def movie_photos(self, subject_id: str, start: int = 0, count: int = 20,
+                     ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        """
+        电影剧照
+        :param subject_id: 电影id
+        :param start: 开始
+        :param count: 数量
+        :param ts: 时间戳
+        """
+        return self.__invoke(self._urls["movie_photos"] % subject_id,
+                             start=start, count=count, _ts=ts)
+
+    def tv_photos(self, subject_id: str, start: int = 0, count: int = 20,
+                  ts=datetime.strftime(datetime.now(), '%Y%m%d')):
+        """
+        电视剧剧照
+        :param subject_id: 电视剧id
+        :param start: 开始
+        :param count: 数量
+        :param ts: 时间戳
+        """
+        return self.__invoke(self._urls["tv_photos"] % subject_id,
+                             start=start, count=count, _ts=ts)
+
    def clear_cache(self):
        """
        清空LRU缓存
--- a/app/modules/douban/scraper.py
+++ b/app/modules/douban/scraper.py
@@ -41,6 +41,10 @@ class DoubanScraper:
                # 生成电影图片
                self.__save_image(url=mediainfo.poster_path,
                                  file_path=file_path.with_name(f"poster{Path(mediainfo.poster_path).suffix}"))
+                # 背景图
+                if mediainfo.backdrop_path:
+                    self.__save_image(url=mediainfo.backdrop_path,
+                                      file_path=file_path.with_name(f"backdrop{Path(mediainfo.backdrop_path).suffix}"))
            # 电视剧
            else:
                # 不存在时才处理
@@ -51,6 +55,10 @@ class DoubanScraper:
                # 生成根目录图片
                self.__save_image(url=mediainfo.poster_path,
                                  file_path=file_path.with_name(f"poster{Path(mediainfo.poster_path).suffix}"))
+                # 背景图
+                if mediainfo.backdrop_path:
+                    self.__save_image(url=mediainfo.backdrop_path,
+                                      file_path=file_path.with_name(f"backdrop{Path(mediainfo.backdrop_path).suffix}"))
                # 季目录NFO
                if not file_path.with_name("season.nfo").exists():
                    self.__gen_tv_season_nfo_file(mediainfo=mediainfo,
--- a/app/modules/emby/emby.py
+++ b/app/modules/emby/emby.py
@@ -366,7 +366,7 @@ class Emby(metaclass=Singleton):
                        season_episodes[season_index] = []
                    season_episodes[season_index].append(episode_index)
                # 返回
-                return tv_item.get("Id"), season_episodes
+                return item_id, season_episodes
        except Exception as e:
            logger.error(f"连接Shows/Id/Episodes出错：" + str(e))
            return None, None
--- a/app/modules/filetransfer/init.py
+++ b/app/modules/filetransfer/init.py
@@ -45,10 +45,20 @@ class FileTransferModule(_ModuleBase):
        """
        # 获取目标路径
        if not target:
+            # 未指定目的目录，根据源目录选择一个媒体库
            target = self.get_target_path(in_path=path)
-        elif not target.exists() or target.is_file():
-            # 目的路径不存在或者是文件时，找对应的媒体库目录
-            target = self.get_library_path(target)
+            # 拼装媒体库一、二级子目录
+            target = self.__get_dest_dir(mediainfo=mediainfo, target_dir=target)
+        else:
+            # 指定了目的目录
+            if target.is_file():
+                logger.error(f"转移目标路径是一个文件 {target} 是一个文件")
+                return TransferInfo(success=False,
+                                    path=path,
+                                    message=f"{target} 不是有效目录")
+            # 只拼装二级子目录（不要一级目录）
+            target = self.__get_dest_dir(mediainfo=mediainfo, target_dir=target, typename_dir=False)
+
        if not target:
            logger.error("未找到媒体库目录，无法转移文件")
            return TransferInfo(success=False,
@@ -56,6 +66,7 @@ class FileTransferModule(_ModuleBase):
                                message="未找到媒体库目录")
        else:
            logger.info(f"获取转移目标路径：{target}")
+
        # 转移
        return self.transfer_media(in_path=path,
                                   in_meta=meta,
@@ -333,33 +344,42 @@ class FileTransferModule(_ModuleBase):
                                           over_flag=over_flag)

    @staticmethod
-    def __get_dest_dir(mediainfo: MediaInfo, target_dir: Path) -> Path:
+    def __get_dest_dir(mediainfo: MediaInfo, target_dir: Path, typename_dir: bool = True) -> Path:
        """
        根据设置并装媒体库目录
        :param mediainfo: 媒体信息
        :target_dir: 媒体库根目录
+        :typename_dir: 是否加上类型目录
        """
+        if not target_dir:
+            return target_dir
+
        if mediainfo.type == MediaType.MOVIE:
            # 电影
-            if settings.LIBRARY_MOVIE_NAME:
+            if typename_dir:
+                # 目的目录加上类型和二级分类
                target_dir = target_dir / settings.LIBRARY_MOVIE_NAME / mediainfo.category
            else:
-                # 目的目录加上类型和二级分类
-                target_dir = target_dir / mediainfo.type.value / mediainfo.category
+                # 目的目录加上二级分类
+                target_dir = target_dir / mediainfo.category

        if mediainfo.type == MediaType.TV:
            # 电视剧
-            if settings.LIBRARY_ANIME_NAME \
-                    and mediainfo.genre_ids \
+            if mediainfo.genre_ids \
                    and set(mediainfo.genre_ids).intersection(set(settings.ANIME_GENREIDS)):
                # 动漫
-                target_dir = target_dir / settings.LIBRARY_ANIME_NAME / mediainfo.category
-            elif settings.LIBRARY_TV_NAME:
-                # 电视剧
-                target_dir = target_dir / settings.LIBRARY_TV_NAME / mediainfo.category
+                if typename_dir:
+                    target_dir = target_dir / (settings.LIBRARY_ANIME_NAME
+                                               or settings.LIBRARY_TV_NAME) / mediainfo.category
+                else:
+                    target_dir = target_dir / mediainfo.category
            else:
-                # 目的目录加上类型和二级分类
-                target_dir = target_dir / mediainfo.type.value / mediainfo.category
+                # 电视剧
+                if typename_dir:
+                    target_dir = target_dir / settings.LIBRARY_TV_NAME / mediainfo.category
+                else:
+                    target_dir = target_dir / mediainfo.category
+
        return target_dir

    def transfer_media(self,
@@ -389,12 +409,8 @@ class FileTransferModule(_ModuleBase):
        if transfer_type not in ['rclone_copy', 'rclone_move']:
            # 检查目标路径
            if not target_dir.exists():
-                return TransferInfo(success=False,
-                                    path=in_path,
-                                    message=f"{target_dir} 目标路径不存在")
-
-        # 媒体库目的目录
-        target_dir = self.__get_dest_dir(mediainfo=mediainfo, target_dir=target_dir)
+                logger.info(f"目标路径不存在，正在创建：{target_dir} ...")
+                target_dir.mkdir(parents=True, exist_ok=True)

        # 重命名格式
        rename_format = settings.TV_RENAME_FORMAT \
@@ -416,14 +432,6 @@ class FileTransferModule(_ModuleBase):
                rename_dict=self.__get_naming_dict(meta=in_meta,
                                                   mediainfo=mediainfo)
            ).parent
-            # 目录已存在时不处理
-            if new_path.exists():
-                logger.warn(f"目标目录已存在：{new_path}")
-                return TransferInfo(success=False,
-                                    message=f"目标目录已存在：{new_path}",
-                                    path=in_path,
-                                    target_path=new_path,
-                                    is_bluray=bluray_flag)
            # 转移蓝光原盘
            retcode = self.__transfer_dir(file_path=in_path,
                                          new_path=new_path,
@@ -555,12 +563,14 @@ class FileTransferModule(_ModuleBase):
        return {
            # 标题
            "title": mediainfo.title,
-            # 原文件名
-            "original_name": f"{meta.org_string}{file_ext}",
            # 原语种标题
            "original_title": mediainfo.original_title,
-            # 识别名称
+            # 原文件名
+            "original_name": f"{meta.org_string}{file_ext}",
+            # 识别名称（优先使用中文）
            "name": meta.name,
+            # 识别的英文名称（可能为空）
+            "en_name": meta.en_name,
            # 年份
            "year": mediainfo.year or meta.year,
            # 资源类型
@@ -581,6 +591,8 @@ class FileTransferModule(_ModuleBase):
            "tmdbid": mediainfo.tmdb_id,
            # IMDBID
            "imdbid": mediainfo.imdb_id,
+            # 豆瓣ID
+            "doubanid": mediainfo.douban_id,
            # 季号
            "season": meta.season_seq,
            # 集号
@@ -661,20 +673,19 @@ class FileTransferModule(_ModuleBase):
                    continue
            if target_path:
                return target_path
-        # 顺序匹配第1个满足空间存储要求的目录
-        if in_path.exists():
-            file_size = in_path.stat().st_size
-            for path in dest_paths:
-                if SystemUtils.free_space(path) > file_size:
-                    return path
+            # 顺序匹配第1个满足空间存储要求的目录
+            if in_path.exists():
+                file_size = in_path.stat().st_size
+                for path in dest_paths:
+                    if SystemUtils.free_space(path) > file_size:
+                        return path
        # 默认返回第1个
        return dest_paths[0]

-    def media_exists(self, mediainfo: MediaInfo, itemid: str = None) -> Optional[ExistMediaInfo]:
+    def media_exists(self, mediainfo: MediaInfo, **kwargs) -> Optional[ExistMediaInfo]:
        """
-        判断媒体文件是否存在于本地文件系统
+        判断媒体文件是否存在于本地文件系统，只支持标准媒体库结构
        :param mediainfo:  识别的媒体信息
-        :param itemid:  媒体服务器ItemID
        :return: 如不存在返回None，存在时返回信息，包括每季已存在所有集{type: movie/tv, seasons: {season: [episodes]}}
        """
        if not settings.LIBRARY_PATHS:
--- a/app/modules/jellyfin/jellyfin.py
+++ b/app/modules/jellyfin/jellyfin.py
@@ -332,7 +332,7 @@ class Jellyfin(metaclass=Singleton):
                    if not season_episodes.get(season_index):
                        season_episodes[season_index] = []
                    season_episodes[season_index].append(episode_index)
-                return tv_info.get('Id'), season_episodes
+                return item_id, season_episodes
        except Exception as e:
            logger.error(f"连接Shows/Id/Episodes出错：" + str(e))
            return None, None
--- a/app/modules/qbittorrent/init.py
+++ b/app/modules/qbittorrent/init.py
@@ -3,6 +3,7 @@ from pathlib import Path
 from typing import Set, Tuple, Optional, Union, List

 from qbittorrentapi import TorrentFilesList
+from torrentool.torrent import Torrent

 from app import schemas
 from app.core.config import settings
@@ -47,6 +48,21 @@ class QbittorrentModule(_ModuleBase):
        :param category:  分类
        :return: 种子Hash，错误信息
        """
+
+        def __get_torrent_info() -> Tuple[str, int]:
+            """
+            获取种子名称
+            """
+            try:
+                if isinstance(content, Path):
+                    torrentinfo = Torrent.from_file(content)
+                else:
+                    torrentinfo = Torrent.from_string(content)
+                return torrentinfo.name, torrentinfo.total_size
+            except Exception as e:
+                logger.error(f"获取种子名称失败：{e}")
+                return "", 0
+
        if not content:
            return
        if isinstance(content, Path) and not content.exists():
@@ -70,6 +86,28 @@ class QbittorrentModule(_ModuleBase):
            category=category
        )
        if not state:
+            # 读取种子的名称
+            torrent_name, torrent_size = __get_torrent_info()
+            if not torrent_name:
+                return None, f"添加种子任务失败：无法读取种子文件"
+            # 查询所有下载器的种子
+            torrents, error = self.qbittorrent.get_torrents()
+            if error:
+                return None, "无法连接qbittorrent下载器"
+            if torrents:
+                for torrent in torrents:
+                    # 名称与大小相等则认为是同一个种子
+                    if torrent.get("name") == torrent_name and torrent.get("total_size") == torrent_size:
+                        torrent_hash = torrent.get("hash")
+                        torrent_tags = [str(tag).strip() for tag in torrent.get("tags").split(',')]
+                        logger.warn(f"下载器中已存在该种子任务：{torrent_hash} - {torrent.get('name')}")
+                        # 给种子打上标签
+                        if "已整理" in torrent_tags:
+                            self.qbittorrent.remove_torrents_tag(ids=torrent_hash, tag=['已整理'])
+                        if settings.TORRENT_TAG and settings.TORRENT_TAG not in torrent_tags:
+                            logger.info(f"给种子 {torrent_hash} 打上标签：{settings.TORRENT_TAG}")
+                            self.qbittorrent.set_torrents_tag(ids=torrent_hash, tags=[settings.TORRENT_TAG])
+                        return torrent_hash, f"下载任务已存在"
            return None, f"添加种子任务失败：{content}"
        else:
            # 获取种子Hash
--- a/app/modules/qbittorrent/qbittorrent.py
+++ b/app/modules/qbittorrent/qbittorrent.py
@@ -16,14 +16,20 @@ class Qbittorrent(metaclass=Singleton):
    _host: str = None
    _port: int = None
    _username: str = None
-    _passowrd: str = None
+    _password: str = None

    qbc: Client = None

-    def __init__(self):
-        self._host, self._port = StringUtils.get_domain_address(address=settings.QB_HOST, prefix=True)
-        self._username = settings.QB_USER
-        self._password = settings.QB_PASSWORD
+    def __init__(self, host: str = None, port: int = None, username: str = None, password: str = None):
+        """
+        若不设置参数，则创建配置文件设置的下载器
+        """
+        if host and port:
+            self._host, self._port = host, port
+        else:
+            self._host, self._port = StringUtils.get_domain_address(address=settings.QB_HOST, prefix=True)
+        self._username = username if username else settings.QB_USER
+        self._password = password if password else settings.QB_PASSWORD
        if self._host and self._port:
            self.qbc = self.__login_qbittorrent()

@@ -352,26 +358,28 @@ class Qbittorrent(metaclass=Singleton):
            logger.error(f"设置速度限制出错：{str(err)}")
            return False

-    def recheck_torrents(self, ids: Union[str, list]):
+    def recheck_torrents(self, ids: Union[str, list]) -> bool:
        """
        重新校验种子
        """
        if not self.qbc:
            return False
        try:
-            return self.qbc.torrents_recheck(torrent_hashes=ids)
+            self.qbc.torrents_recheck(torrent_hashes=ids)
+            return True
        except Exception as err:
            logger.error(f"重新校验种子出错：{str(err)}")
            return False

-    def add_trackers(self, ids: Union[str, list], trackers: list):
+    def update_tracker(self, hash_string: str, tracker_list: list) -> bool:
        """
        添加tracker
        """
        if not self.qbc:
            return False
        try:
-            return self.qbc.torrents_add_trackers(torrent_hashes=ids, urls=trackers)
+            self.qbc.torrents_add_trackers(torrent_hash=hash_string, urls=tracker_list)
+            return True
        except Exception as err:
-            logger.error(f"添加tracker出错：{str(err)}")
+            logger.error(f"修改tracker出错：{str(err)}")
            return False
--- a/app/modules/telegram/telegram.py
+++ b/app/modules/telegram/telegram.py
@@ -12,6 +12,7 @@ from app.core.config import settings
 from app.core.context import MediaInfo, Context
 from app.core.metainfo import MetaInfo
 from app.log import logger
+from app.utils.common import retry
 from app.utils.http import RequestUtils
 from app.utils.singleton import Singleton
 from app.utils.string import StringUtils
@@ -174,6 +175,7 @@ class Telegram(metaclass=Singleton):
            logger.error(f"发送消息失败：{msg_e}")
            return False

+    @retry(Exception, logger=logger)
    def __send_request(self, userid: str = None, image="", caption="") -> bool:
        """
        向Telegram发送报文
@@ -181,7 +183,9 @@ class Telegram(metaclass=Singleton):

        if image:
            req = RequestUtils(proxies=settings.PROXY).get_res(image)
-            if req and req.content:
+            if req is None:
+                raise Exception("获取图片失败")
+            if req.content:
                image_file = Path(settings.TEMP_PATH) / Path(image).name
                image_file.write_bytes(req.content)
                photo = InputFile(image_file)
@@ -189,12 +193,15 @@ class Telegram(metaclass=Singleton):
                                           photo=photo,
                                           caption=caption,
                                           parse_mode="Markdown")
+                if ret is None:
+                    raise Exception("发送图片消息失败")
                if ret:
                    return True
        ret = self._bot.send_message(chat_id=userid or self._telegram_chat_id,
                                     text=caption,
                                     parse_mode="Markdown")
-
+        if ret is None:
+            raise Exception("发送文本消息失败")
        return True if ret else False

    def register_commands(self, commands: Dict[str, dict]):
--- a/app/modules/themoviedb/init.py
+++ b/app/modules/themoviedb/init.py
@@ -312,6 +312,8 @@ class TheMovieDbModule(_ModuleBase):
        :param mediainfo:  识别的媒体信息
        :return: 更新后的媒体信息
        """
+        if settings.RECOGNIZE_SOURCE != "themoviedb":
+            return None
        if not mediainfo.tmdb_id:
            return mediainfo
        if mediainfo.logo_path \
@@ -382,35 +384,35 @@ class TheMovieDbModule(_ModuleBase):
            return f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/{image_prefix}{image_path}"
        return None

-    def movie_similar(self, tmdbid: int) -> List[dict]:
+    def tmdb_movie_similar(self, tmdbid: int) -> List[dict]:
        """
        根据TMDBID查询类似电影
        :param tmdbid:  TMDBID
        """
        return self.tmdb.get_movie_similar(tmdbid=tmdbid)

-    def tv_similar(self, tmdbid: int) -> List[dict]:
+    def tmdb_tv_similar(self, tmdbid: int) -> List[dict]:
        """
        根据TMDBID查询类似电视剧
        :param tmdbid:  TMDBID
        """
        return self.tmdb.get_tv_similar(tmdbid=tmdbid)

-    def movie_recommend(self, tmdbid: int) -> List[dict]:
+    def tmdb_movie_recommend(self, tmdbid: int) -> List[dict]:
        """
        根据TMDBID查询推荐电影
        :param tmdbid:  TMDBID
        """
        return self.tmdb.get_movie_recommend(tmdbid=tmdbid)

-    def tv_recommend(self, tmdbid: int) -> List[dict]:
+    def tmdb_tv_recommend(self, tmdbid: int) -> List[dict]:
        """
        根据TMDBID查询推荐电视剧
        :param tmdbid:  TMDBID
        """
        return self.tmdb.get_tv_recommend(tmdbid=tmdbid)

-    def movie_credits(self, tmdbid: int, page: int = 1) -> List[dict]:
+    def tmdb_movie_credits(self, tmdbid: int, page: int = 1) -> List[dict]:
        """
        根据TMDBID查询电影演职员表
        :param tmdbid:  TMDBID
@@ -418,7 +420,7 @@ class TheMovieDbModule(_ModuleBase):
        """
        return self.tmdb.get_movie_credits(tmdbid=tmdbid, page=page)

-    def tv_credits(self, tmdbid: int, page: int = 1) -> List[dict]:
+    def tmdb_tv_credits(self, tmdbid: int, page: int = 1) -> List[dict]:
        """
        根据TMDBID查询电视剧演职员表
        :param tmdbid:  TMDBID
@@ -426,14 +428,14 @@ class TheMovieDbModule(_ModuleBase):
        """
        return self.tmdb.get_tv_credits(tmdbid=tmdbid, page=page)

-    def person_detail(self, person_id: int) -> dict:
+    def tmdb_person_detail(self, person_id: int) -> dict:
        """
        根据TMDBID查询人物详情
        :param person_id:  人物ID
        """
        return self.tmdb.get_person_detail(person_id=person_id)

-    def person_credits(self, person_id: int, page: int = 1) -> List[dict]:
+    def tmdb_person_credits(self, person_id: int, page: int = 1) -> List[dict]:
        """
        根据TMDBID查询人物参演作品
        :param person_id:  人物ID
@@ -445,5 +447,7 @@ class TheMovieDbModule(_ModuleBase):
        """
        清除缓存
        """
+        logger.info("开始清除TMDB缓存 ...")
        self.tmdb.clear_cache()
        self.cache.clear()
+        logger.info("TMDB缓存清除完成")
--- a/app/modules/themoviedb/scraper.py
+++ b/app/modules/themoviedb/scraper.py
@@ -120,10 +120,11 @@ class TmdbScraper:
                                                       file_path=file_path)
                    # 集的图片
                    episode_image = episodeinfo.get("still_path")
+                    image_path = file_path.with_name(file_path.stem + "-thumb").with_suffix(Path(episode_image).suffix)
                    if episode_image:
                        self.__save_image(
                            f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/original{episode_image}",
-                            file_path.with_suffix(Path(episode_image).suffix))
+                            image_path)
        except Exception as e:
            logger.error(f"{file_path} 刮削失败：{str(e)}")

--- a/app/modules/transmission/init.py
+++ b/app/modules/transmission/init.py
@@ -2,6 +2,7 @@ import shutil
 from pathlib import Path
 from typing import Set, Tuple, Optional, Union, List

+from torrentool.torrent import Torrent
 from transmission_rpc import File

 from app import schemas
@@ -47,6 +48,21 @@ class TransmissionModule(_ModuleBase):
        :param category:  分类，TR中未使用
        :return: 种子Hash
        """
+
+        def __get_torrent_info() -> Tuple[str, int]:
+            """
+            获取种子名称
+            """
+            try:
+                if isinstance(content, Path):
+                    torrentinfo = Torrent.from_file(content)
+                else:
+                    torrentinfo = Torrent.from_string(content)
+                return torrentinfo.name, torrentinfo.total_size
+            except Exception as e:
+                logger.error(f"获取种子名称失败：{e}")
+                return "", 0
+
        if not content:
            return
        if isinstance(content, Path) and not content.exists():
@@ -68,6 +84,33 @@ class TransmissionModule(_ModuleBase):
            cookie=cookie
        )
        if not torrent:
+            # 读取种子的名称
+            torrent_name, torrent_size = __get_torrent_info()
+            if not torrent_name:
+                return None, f"添加种子任务失败：无法读取种子文件"
+            # 查询所有下载器的种子
+            torrents, error = self.transmission.get_torrents()
+            if error:
+                return None, "无法连接transmission下载器"
+            if torrents:
+                for torrent in torrents:
+                    # 名称与大小相等则认为是同一个种子
+                    if torrent.name == torrent_name and torrent.total_size == torrent_size:
+                        torrent_hash = torrent.hashString
+                        logger.warn(f"下载器中已存在该种子任务：{torrent_hash} - {torrent.name}")
+                        # 给种子打上标签
+                        if settings.TORRENT_TAG:
+                            logger.info(f"给种子 {torrent_hash} 打上标签：{settings.TORRENT_TAG}")
+                            # 种子标签
+                            labels = [str(tag).strip()
+                                      for tag in torrent.labels] if hasattr(torrent, "labels") else []
+                            if "已整理" in labels:
+                                labels.remove("已整理")
+                                self.transmission.set_torrent_tag(ids=torrent_hash, tags=labels)
+                            if settings.TORRENT_TAG and settings.TORRENT_TAG not in labels:
+                                labels.append(settings.TORRENT_TAG)
+                                self.transmission.set_torrent_tag(ids=torrent_hash, tags=labels)
+                        return torrent_hash, f"下载任务已存在"
            return None, f"添加种子任务失败：{content}"
        else:
            torrent_hash = torrent.hashString
--- a/app/modules/transmission/transmission.py
+++ b/app/modules/transmission/transmission.py
@@ -14,7 +14,7 @@ class Transmission(metaclass=Singleton):
    _host: str = None
    _port: int = None
    _username: str = None
-    _passowrd: str = None
+    _password: str = None

    trc: Optional[Client] = None

@@ -24,10 +24,16 @@ class Transmission(metaclass=Singleton):
              "peersGettingFromUs", "peersSendingToUs", "uploadRatio", "uploadedEver", "downloadedEver", "downloadDir",
              "error", "errorString", "doneDate", "queuePosition", "activityDate", "trackers"]

-    def __init__(self):
-        self._host, self._port = StringUtils.get_domain_address(address=settings.TR_HOST, prefix=False)
-        self._username = settings.TR_USER
-        self._password = settings.TR_PASSWORD
+    def __init__(self, host: str = None, port: int = None, username: str = None, password: str = None):
+        """
+        若不设置参数，则创建配置文件设置的下载器
+        """
+        if host and port:
+            self._host, self._port = host, port
+        else:
+            self._host, self._port = StringUtils.get_domain_address(address=settings.TR_HOST, prefix=False)
+        self._username = username if username else settings.TR_USER
+        self._password = password if password else settings.TR_PASSWORD
        if self._host and self._port:
            self.trc = self.__login_transmission()

@@ -271,36 +277,25 @@ class Transmission(metaclass=Singleton):
            logger.error(f"设置速度限制出错：{str(err)}")
            return False

-    def recheck_torrents(self, ids: Union[str, list]):
+    def recheck_torrents(self, ids: Union[str, list]) -> bool:
        """
        重新校验种子
        """
        if not self.trc:
            return False
        try:
-            return self.trc.verify_torrent(ids=ids)
+            self.trc.verify_torrent(ids=ids)
+            return True
        except Exception as err:
            logger.error(f"重新校验种子出错：{str(err)}")
            return False

-    def add_trackers(self, ids: Union[str, list], trackers: list):
-        """
-        添加Tracker
-        """
-        if not self.trc:
-            return False
-        try:
-            return self.trc.change_torrent(ids=ids, tracker_list=[trackers])
-        except Exception as err:
-            logger.error(f"添加Tracker出错：{str(err)}")
-            return False
-
    def change_torrent(self,
                       hash_string: str,
                       upload_limit=None,
                       download_limit=None,
                       ratio_limit=None,
-                       seeding_time_limit=None):
+                       seeding_time_limit=None) -> bool:
        """
        设置种子
        :param hash_string: ID
@@ -346,6 +341,22 @@ class Transmission(metaclass=Singleton):
                                    seedRatioLimit=seedRatioLimit,
                                    seedIdleMode=seedIdleMode,
                                    seedIdleLimit=seedIdleLimit)
+            return True
        except Exception as err:
            logger.error(f"设置种子出错：{str(err)}")
            return False
+
+    def update_tracker(self, hash_string: str, tracker_list: list = None) -> bool:
+        """
+        tr4.0及以上弃用直接设置tracker 共用change方法
+        https://github.com/trim21/transmission-rpc/blob/8eb82629492a0eeb0bb565f82c872bf9ccdcb313/transmission_rpc/client.py#L654
+        """
+        if not self.trc:
+            return False
+        try:
+            self.trc.change_torrent(ids=hash_string,
+                                    tracker_list=tracker_list)
+            return True
+        except Exception as err:
+            logger.error(f"修改tracker出错：{str(err)}")
+            return False
--- a/app/scheduler.py
+++ b/app/scheduler.py
@@ -13,6 +13,7 @@ from app.chain.cookiecloud import CookieCloudChain
 from app.chain.mediaserver import MediaServerChain
 from app.chain.subscribe import SubscribeChain
 from app.chain.tmdb import TmdbChain
+from app.chain.torrents import TorrentsChain
 from app.chain.transfer import TransferChain
 from app.core.config import settings
 from app.log import logger
@@ -43,6 +44,14 @@ class Scheduler(metaclass=Singleton):
    _event = threading.Event()

    def __init__(self):
+
+        def clear_cache():
+            """
+            清理缓存
+            """
+            TorrentsChain().clear_cache()
+            SchedulerChain().clear_cache()
+
        # 各服务的运行状态
        self._jobs = {
            "cookiecloud": {
@@ -73,7 +82,7 @@ class Scheduler(metaclass=Singleton):
                "running": False,
            },
            "clear_cache": {
-                "func": SchedulerChain().clear_cache,
+                "func": clear_cache,
                "running": False,
            }
        }
--- a/app/schemas/plugin.py
+++ b/app/schemas/plugin.py
@@ -14,8 +14,6 @@ class Plugin(BaseModel):
    plugin_desc: Optional[str] = None
    # 插件图标
    plugin_icon: Optional[str] = None
-    # 主题色
-    plugin_color: Optional[str] = None
    # 插件版本
    plugin_version: Optional[str] = None
    # 插件作者
--- a/app/schemas/subscribe.py
+++ b/app/schemas/subscribe.py
@@ -57,6 +57,8 @@ class Subscribe(BaseModel):
    best_version: Optional[int] = 0
    # 当前优先级
    current_priority: Optional[int] = None
+    # 保存路径
+    save_path: Optional[str] = None

    class Config:
        orm_mode = True
--- a/app/schemas/tmdb.py
+++ b/app/schemas/tmdb.py
@@ -49,3 +49,14 @@ class TmdbPerson(BaseModel):
    popularity: Optional[float] = None
    images: Optional[dict] = {}
    biography: Optional[str] = None
+
+
+class DoubanPerson(BaseModel):
+    id: Optional[str] = None
+    name: Optional[str] = None
+    roles: Optional[list] = []
+    title: Optional[str] = None
+    url: Optional[str] = None
+    character: Optional[str] = None
+    avatar: Optional[dict] = None
+    latin_name: Optional[str] = None
--- a/app/schemas/types.py
+++ b/app/schemas/types.py
@@ -16,16 +16,12 @@ class TorrentStatus(Enum):
 class EventType(Enum):
    # 插件重载
    PluginReload = "plugin.reload"
+    # 插件动作
+    PluginAction = "plugin.action"
    # 执行命令
    CommandExcute = "command.excute"
-    # 站点签到
-    SiteSignin = "site.signin"
-    # 站点数据统计
-    SiteStatistic = "site.statistic"
    # 站点删除
    SiteDeleted = "site.deleted"
-    # 豆瓣想看
-    DoubanSync = "douban.sync"
    # Webhook消息
    WebhookMessage = "webhook.message"
    # 转移完成
@@ -44,14 +40,6 @@ class EventType(Enum):
    NameRecognize = "name.recognize"
    # 名称识别结果
    NameRecognizeResult = "name.recognize.result"
-    # 目录监控同步
-    DirectorySync = "directory.sync"
-    # Cloudflare IP优选
-    CloudFlareSpeedTest = "cloudflare.speedtest"
-    # 站点自动登录更新Cookie、Ua
-    SiteLogin = "site.login"
-    # 网盘删除
-    NetworkDiskDel = "networkdisk.del"


 # 系统配置Key字典
--- a/app/utils/singleton.py
+++ b/app/utils/singleton.py
@@ -9,9 +9,10 @@ class Singleton(abc.ABCMeta, type):
    _instances: dict = {}

    def __call__(cls, *args, **kwargs):
-        if cls not in cls._instances:
-            cls._instances[cls] = super(Singleton, cls).__call__(*args, **kwargs)
-        return cls._instances[cls]
+        key = (cls, args, frozenset(kwargs.items()))
+        if key not in cls._instances:
+            cls._instances[key] = super().__call__(*args, **kwargs)
+        return cls._instances[key]


 class AbstractSingleton(abc.ABC, metaclass=Singleton):
--- a/config/app.env
+++ b/config/app.env
@@ -3,9 +3,9 @@
 #######################################################################

 ####################################
-#  基础设置                         #
+#  系统设置                         #
 ####################################
-# 【*】API监听地址
+# 【*】API监听地址（注意不是前端访问地址）
 HOST=0.0.0.0
 # 是否调试模式，打开后将输出更多日志
 DEBUG=false
@@ -15,6 +15,94 @@ DEV=false
 SUPERUSER=admin
 # 【*】超级管理员初始密码，设置后一但重启将固化到数据库中，修改将无效
 SUPERUSER_PASSWORD=password
+# 大内存模式，开启后会增加缓存数量，但会占用更多内存
+BIG_MEMORY_MODE=false
+# 自动检查和更新站点资源包（索引、认证等）
+AUTO_UPDATE_RESOURCE=true
+
+####################################
+#   消息通知渠道（按需配置）          #
+####################################
+# WeChat企业ID
+WECHAT_CORPID=
+# WeChat应用Secret
+WECHAT_APP_SECRET=
+# WeChat应用ID
+WECHAT_APP_ID=
+# WeChat代理服务器，无需代理需保留默认值
+WECHAT_PROXY=https://qyapi.weixin.qq.com
+# WeChat Token
+WECHAT_TOKEN=
+# WeChat EncodingAESKey
+WECHAT_ENCODING_AESKEY=
+# WeChat 管理员
+WECHAT_ADMINS=
+
+# Telegram Bot Token
+TELEGRAM_TOKEN=
+# Telegram Chat ID
+TELEGRAM_CHAT_ID=
+# Telegram 用户ID，使用,分隔
+TELEGRAM_USERS=
+# Telegram 管理员ID，使用,分隔
+TELEGRAM_ADMINS=
+
+# Slack Bot User OAuth Token
+SLACK_OAUTH_TOKEN=
+# Slack App-Level Token
+SLACK_APP_TOKEN=
+# Slack 频道名称
+SLACK_CHANNEL=
+
+# SynologyChat Webhook
+SYNOLOGYCHAT_WEBHOOK=
+# SynologyChat Token
+SYNOLOGYCHAT_TOKEN=
+
+####################################
+#   下载器（按需配置）               #
+####################################
+# Qbittorrent地址，IP:PORT
+QB_HOST=
+# Qbittorrent用户名
+QB_USER=
+# Qbittorrent密码
+QB_PASSWORD=
+# Qbittorrent分类自动管理
+QB_CATEGORY=false
+# Qbittorrent按顺序下载
+QB_SEQUENTIAL=true
+# Qbittorrent忽略队列限制，强制继续
+QB_FORCE_RESUME=true
+
+# Transmission地址，IP:PORT
+TR_HOST=
+# Transmission用户名
+TR_USER=
+# Transmission密码
+TR_PASSWORD=
+
+####################################
+#   媒体服务器（按需配置）            #
+####################################
+# EMBY服务器地址，IP:PORT
+EMBY_HOST=
+# EMBY Api Key
+EMBY_API_KEY=
+
+# Jellyfin服务器地址，IP:PORT
+JELLYFIN_HOST=
+# Jellyfin Api Key
+JELLYFIN_API_KEY=
+
+# Plex服务器地址，IP:PORT
+PLEX_HOST=
+# Plex Token
+PLEX_TOKEN=
+
+####################################
+#  基础设置                         #
+####################################
 # 【*】API密钥，建议更换复杂字符串，有Jellyseerr/Overseerr、媒体服务器Webhook等配置以及部分支持API_TOKEN的API中使用
 API_TOKEN=moviepilot
 # 登录页面电影海报，tmdb/bing，tmdb要求能正常连接api.themoviedb.org
@@ -25,8 +113,21 @@ TMDB_IMAGE_DOMAIN=image.tmdb.org
 TMDB_API_DOMAIN=api.themoviedb.org
 # 媒体识别来源 themoviedb/douban，使用themoviedb时需要确保能正常连接api.themoviedb.org，使用douban时不支持二级分类
 RECOGNIZE_SOURCE=themoviedb
-# 大内存模式，开启后会增加缓存数量，但会占用更多内存
-BIG_MEMORY_MODE=false
+
+# 【*】消息通知渠道 telegram/wechat/slack，多个通知渠道用,分隔，需要在上面配置对应消息通知渠道的参数
+MESSAGER=telegram
+
+# 【*】下载器 qbittorrent/transmission，仅支持单个下载器，做为主下载器使用，需要在上面配置对应消下载器的参数
+DOWNLOADER=qbittorrent
+# 下载器监控开关
+DOWNLOADER_MONITOR=true
+
+# 【*】媒体服务器 emby/jellyfin/plex，多个媒体服务器,分割
+MEDIASERVER=emby
+# 媒体服务器同步间隔（小时）
+MEDIASERVER_SYNC_INTERVAL=6
+# 媒体服务器同步黑名单，多个媒体库名称,分割
+MEDIASERVER_SYNC_BLACKLIST=

 ####################################
 #  媒体识别&刮削                     #
@@ -39,22 +140,24 @@ SCRAP_FOLLOW_TMDB=true
 SCRAP_SOURCE=themoviedb

 ####################################
-#   媒体库                          #
+#   文件整理 & 媒体库                #
 ####################################
 # 【*】转移方式 link/copy/move/softlink/rclone_copy/rclone_move
 TRANSFER_TYPE=copy
 # 转移覆盖模式，`nerver`/`size`/`always`/`latest`，分别表示`不覆盖同名文件`/`同名文件根据文件大小覆盖（大覆盖小）`/`总是覆盖同名文件`/`仅保留最新版本，删除旧版本文件（包括非同名文件）`
 OVERWRITE_MODE=size
+
 # 【*】媒体库目录，多个目录使用,分隔
-LIBRARY_PATH=
+LIBRARY_PATH=/media
 # 电影媒体库目录名，默认电影
-LIBRARY_MOVIE_NAME=
+LIBRARY_MOVIE_NAME=电影
 # 电视剧媒体库目录名，默认电视剧
-LIBRARY_TV_NAME=
+LIBRARY_TV_NAME=电视剧
 # 动漫媒体库目录名，默认电视剧/动漫
-LIBRARY_ANIME_NAME=
+LIBRARY_ANIME_NAME=电视剧/动漫
 # 二级分类，开启后会根据配置 [category.yaml](https://github.com/jxxghp/MoviePilot/raw/main/config/category.yaml) 自动在媒体库目录下建立二级目录分类
 LIBRARY_CATEGORY=true
+
 # 电影重命名格式，Jinja2语法，参考：https://jinja.palletsprojects.com/en/3.0.x/templates/
 MOVIE_RENAME_FORMAT={{title}}{% if year %} ({{year}}){% endif %}/{{title}}{% if year %} ({{year}}){% endif %}{% if part %}-{{part}}{% endif %}{% if videoFormat %} - {{videoFormat}}{% endif %}{{fileExt}}
 # 电视剧重命名格式，Jinja2语法，参考：https://jinja.palletsprojects.com/en/3.0.x/templates/
@@ -86,71 +189,9 @@ SUBSCRIBE_SEARCH=false
 # 交互搜索自动下载用户ID（消息通知渠道的用户ID），使用,分割，未设置需要用户手动选择资源或者回复`0`
 AUTO_DOWNLOAD_USER=

-####################################
-#   消息通知                        #
-####################################
-# 【*】消息通知渠道 telegram/wechat/slack，多个通知渠道用,分隔
-MESSAGER=telegram
-# WeChat企业ID
-WECHAT_CORPID=
-# WeChat应用Secret
-WECHAT_APP_SECRET=
-# WeChat应用ID
-WECHAT_APP_ID=
-# WeChat代理服务器，无需代理需保留默认值
-WECHAT_PROXY=https://qyapi.weixin.qq.com
-# WeChat Token
-WECHAT_TOKEN=
-# WeChat EncodingAESKey
-WECHAT_ENCODING_AESKEY=
-# WeChat 管理员
-WECHAT_ADMINS=
-# Telegram Bot Token
-TELEGRAM_TOKEN=
-# Telegram Chat ID
-TELEGRAM_CHAT_ID=
-# Telegram 用户ID，使用,分隔
-TELEGRAM_USERS=
-# Telegram 管理员ID，使用,分隔
-TELEGRAM_ADMINS=
-# Slack Bot User OAuth Token
-SLACK_OAUTH_TOKEN=
-# Slack App-Level Token
-SLACK_APP_TOKEN=
-# Slack 频道名称
-SLACK_CHANNEL=
-# SynologyChat Webhook
-SYNOLOGYCHAT_WEBHOOK=
-# SynologyChat Token
-SYNOLOGYCHAT_TOKEN=
-
 ####################################
 #   下载                           #
 ####################################
-# 【*】下载器 qbittorrent/transmission，仅支持单个下载器，做为主下载器使用，非主下载器只要配置了参数仍可在插件等使用
-DOWNLOADER=qbittorrent
-# 下载器监控开关
-DOWNLOADER_MONITOR=true
-# Qbittorrent地址，IP:PORT
-QB_HOST=
-# Qbittorrent用户名
-QB_USER=
-# Qbittorrent密码
-QB_PASSWORD=
-# Qbittorrent分类自动管理
-QB_CATEGORY=false
-# Qbittorrent按顺序下载
-QB_SEQUENTIAL=true
-# Qbittorrent忽略队列限制，强制继续
-QB_FORCE_RESUME=false
-# Transmission地址，IP:PORT
-TR_HOST=
-# Transmission用户名
-TR_USER=
-# Transmission密码
-TR_PASSWORD=
-# 种子标签
-TORRENT_TAG=MOVIEPILOT
 # 【*】下载保存目录，容器内映射路径需要一致，支持不同类型设置不同的下载目录（跨盘）
 DOWNLOAD_PATH=/downloads
 # 电影下载保存目录（路径），容器内映射路径需要一致
@@ -159,38 +200,19 @@ DOWNLOAD_MOVIE_PATH=
 DOWNLOAD_TV_PATH=
 # 动漫下载保存目录（路径），容器内映射路径需要一致
 DOWNLOAD_ANIME_PATH=
+
 # 下载目录二级分类，开启后会根据配置 [category.yaml](https://github.com/jxxghp/MoviePilot/raw/main/config/category.yaml) 自动在下载目录下建立二级目录分类
 DOWNLOAD_CATEGORY=false
-# 下载站点字幕
+# 种子标签
+TORRENT_TAG=MOVIEPILOT
+# 自动下载站点字幕（如有）
 DOWNLOAD_SUBTITLE=true

 ####################################
-#   媒体服务器                      #
-####################################
-# 【*】媒体服务器 emby/jellyfin/plex，多个媒体服务器,分割
-MEDIASERVER=emby
-# 媒体服务器同步间隔（小时）
-MEDIASERVER_SYNC_INTERVAL=6
-# 媒体服务器同步黑名单，多个媒体库名称,分割
-MEDIASERVER_SYNC_BLACKLIST=
-# EMBY服务器地址，IP:PORT
-EMBY_HOST=
-# EMBY Api Key
-EMBY_API_KEY=
-# Jellyfin服务器地址，IP:PORT
-JELLYFIN_HOST=
-# Jellyfin Api Key
-JELLYFIN_API_KEY=
-# Plex服务器地址，IP:PORT
-PLEX_HOST=
-# Plex Token
-PLEX_TOKEN=
-
-####################################
-#   第三方服务                      #
+#   扩展                           #
 ####################################
 # OCR服务器地址
 OCR_HOST=https://movie-pilot.org
 # 插件市场仓库地址，多个地址使用`,`分隔，保留最后的/
-PLUGIN_MARKET=https://raw.githubusercontent.com/jxxghp/MoviePilot-Plugins/main/
+PLUGIN_MARKET=https://github.com/jxxghp/MoviePilot-Plugins

--- a/database/env.py
+++ b/database/env.py
@@ -5,7 +5,7 @@ from sqlalchemy import pool

 from alembic import context

-from app.db.models import Base
+from app.db import Base
 # this is the Alembic Config object, which provides
 # access to the values within the .ini file in use.
 config = context.config
--- a/database/versions/d71e624f0208_1_0_12.py
+++ b/database/versions/d71e624f0208_1_0_12.py
@@ -0,0 +1,30 @@
+"""1_0_12
+
+Revision ID: d71e624f0208
+Revises: 06abf3e7090b
+Create Date: 2023-12-12 13:26:34.039497
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = 'd71e624f0208'
+down_revision = '06abf3e7090b'
+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('save_path', sa.String, nullable=True))
+    except Exception as e:
+        pass
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    pass
--- a/windows.spec
+++ b/windows.spec
@@ -8,17 +8,22 @@ def collect_pkg_data(package: str, include_py_files: bool = False, subdir: str =
    from PyInstaller.utils.hooks import get_package_paths, PY_IGNORE_EXTENSIONS
    from PyInstaller.building.datastruct import TOC

+    data_toc = TOC()
+
    # Accept only strings as packages.
    if type(package) is not str:
        raise ValueError
-
-    pkg_base, pkg_dir = get_package_paths(package)
+    try:
+        pkg_base, pkg_dir = get_package_paths(package)
+    except ValueError:
+        return data_toc
    if subdir:
        pkg_path = Path(pkg_dir) / subdir
    else:
        pkg_path = Path(pkg_dir)
    # Walk through all file in the given package, looking for data files.
-    data_toc = TOC()
+    if not pkg_path.exists():
+        return data_toc
    for file in pkg_path.rglob('*'):
        if file.is_file():
            extension = file.suffix
@@ -37,6 +42,8 @@ def collect_local_submodules(package: str):
    package_dir = Path(package.replace('.', os.sep))
    submodules = [package]
    # Walk through all file in the given package, looking for data files.
+    if not package_dir.exists():
+        return []
    for file in package_dir.rglob('*.py'):
        if file.name == '__init__.py':
            module = f"{file.parent}".replace(os.sep, '.')
@@ -82,6 +89,7 @@ exe = EXE(
    collect_pkg_data('zhconv'),
    collect_pkg_data('cn2an'),
    collect_pkg_data('database', include_py_files=True),
+    collect_pkg_data('app.helper'),
    [],
    name='MoviePilot',
    debug=False,
--- a/11
+++ b/11
@@ -5,7 +5,7 @@ download_and_unzip() {
    url="$1"
    target_dir="$2"
    echo "正在下载 ${url}..."
-    curl ${CURL_OPTIONS} "$url" | busybox unzip -d /tmp -
+    curl ${CURL_OPTIONS} "$url" ${CURL_HEADERS} | busybox unzip -d /tmp -
    if [ $? -eq 0 ]; then
        if [ -e /tmp/MoviePilot-* ]; then
            mv /tmp/MoviePilot-* /tmp/${target_dir}
@@ -30,7 +30,7 @@ install_backend_and_download_resources() {
                download_and_unzip "https://github.com/jxxghp/MoviePilot-Resources/archive/refs/heads/main.zip" "Resources"
                if [ $? -eq 0 ]; then
                    echo "资源包下载成功"
-                    frontend_version=$(curl ${CURL_OPTIONS} "https://api.github.com/repos/jxxghp/MoviePilot-Frontend/releases/latest" | jq -r .tag_name)
+                    frontend_version=$(curl ${CURL_OPTIONS} "https://api.github.com/repos/jxxghp/MoviePilot-Frontend/releases/latest" ${CURL_HEADERS} | jq -r .tag_name)
                    if [[ "${frontend_version}" == *v* ]]; then
                        download_and_unzip "https://github.com/jxxghp/MoviePilot-Frontend/releases/download/${frontend_version}/dist.zip" "dist"
                        if [ $? -eq 0 ]; then
@@ -83,6 +83,11 @@ if [[ "${MOVIEPILOT_AUTO_UPDATE}" = "true" ]] || [[ "${MOVIEPILOT_AUTO_UPDATE}"
        CURL_OPTIONS="-sL"
        echo "不使用代理更新程序"
    fi
+    if [ -n "${GITHUB_TOKEN}" ]; then
+        CURL_HEADERS="--header 'Authorization: Bearer ${GITHUB_TOKEN}'"
+    else
+        CURL_HEADERS=""
+    fi
    if [ "${MOVIEPILOT_AUTO_UPDATE}" = "dev" ]; then
        echo "Dev 更新模式"
        install_backend_and_download_resources "heads/main.zip"
@@ -92,7 +97,7 @@ if [[ "${MOVIEPILOT_AUTO_UPDATE}" = "true" ]] || [[ "${MOVIEPILOT_AUTO_UPDATE}"
        if [[ "${old_version}" == *APP_VERSION* ]]; then
            current_version=v$(echo ${old_version} | sed -ne "s/APP_VERSION\s=\s'v\(.*\)'/\1/gp")
            echo "当前版本号：${current_version}"
-            new_version=$(curl ${CURL_OPTIONS} "https://api.github.com/repos/jxxghp/MoviePilot/releases/latest" | jq -r .tag_name)
+            new_version=$(curl ${CURL_OPTIONS} "https://api.github.com/repos/jxxghp/MoviePilot/releases/latest" ${CURL_HEADERS} | jq -r .tag_name)
            if [[ "${new_version}" == *v* ]]; then
                release_version=${new_version}
                echo "最新版本号：${release_version}"
--- a/version.py
+++ b/version.py
@@ -1 +1 @@
-APP_VERSION = 'v1.4.2'
+APP_VERSION = 'v1.5.2'
Author	SHA1	Message	Date
jxxghp	cb12a052ac	- 修复历史记录重新整理时路径不正确的问题	2023-12-16 12:21:22 +08:00
jxxghp	995c359f20	Merge pull request #1234 from thsrite/main	2023-12-14 06:28:50 +08:00
jxxghp	690066ad32	- 修复整理时不自动创建目标路径的问题	2023-12-13 06:53:11 +08:00
thsrite	73942e315a	feat 订阅增加保存路径设置	2023-12-12 14:01:14 +08:00
jxxghp	48badb3243	Merge pull request #1228 from EkkoG/fixed_move_failed_msg	2023-12-11 19:31:19 +08:00
EkkoG	d5eb12cc4e	修复无法入库消息发送到 Telegram 时格式异常	2023-12-11 17:51:21 +08:00
jxxghp	7d7539df4c	- 目录监控、手动整理等不指定目的目录时，不再强制创建一级分类目录，根据开关判定是否创建二级分类目录	2023-12-11 17:24:34 +08:00
jxxghp	14a8f44f8c	fix bug	2023-12-10 18:51:20 +08:00
jxxghp	a7be470f33	v1.5.0	2023-12-10 17:49:05 +08:00
jxxghp	a677169f60	fix #1219 指定转移目录时不强制添加一级分类目录	2023-12-10 17:48:14 +08:00
jxxghp	b72ef4f2aa	fix #1139 洗版重复下载问题	2023-12-10 17:27:34 +08:00
jxxghp	403054751b	Merge remote-tracking branch 'origin/main'	2023-12-10 13:35:01 +08:00
jxxghp	b3e5c734d4	add ffmpeg	2023-12-10 13:34:54 +08:00
jxxghp	5732125ff6	Merge pull request #1221 from Vincwnt/main	2023-12-10 11:52:53 +08:00
林晓昱	eb66cf7aad	fix 自定义识别词的媒体type正则bug	2023-12-10 11:34:39 +08:00
jxxghp	a317c35eab	fix 集图片命名	2023-12-06 13:08:15 +08:00
jxxghp	ab138560c1	v1.4.9	2023-12-06 10:55:31 +08:00
jxxghp	f0fbad889d	- 偿试修复可执行文件打包插件数据表缺失问题	2023-12-05 20:57:53 +08:00
jxxghp	1323cd5dc6	fix 插件下载Bug	2023-12-04 17:27:33 +08:00
jxxghp	2c43d8e145	fix 插件下载Bug	2023-12-04 16:58:39 +08:00
jxxghp	0214beb679	- 修复二进制打包插件表缺失的问题	2023-12-04 11:33:16 +08:00
jxxghp	7d73cdef33	Merge remote-tracking branch 'origin/main'	2023-12-04 11:03:00 +08:00
jxxghp	fcfab2c750	feat 命名增加豆瓣ID/识别英文名称	2023-12-04 11:02:53 +08:00
jxxghp	e048be17a5	Merge pull request #1195 from WithdewHua/fix-mediaserver	2023-12-02 12:47:20 +08:00
WithdewHua	024f1de4f1	fix: 清空 MediaServerItem 表	2023-12-02 12:31:38 +08:00
jxxghp	d2c9f7a778	更新 README.md	2023-12-01 18:39:40 +08:00
jxxghp	1784d2ec61	v1.4.8	2023-12-01 10:51:49 +08:00
jxxghp	8f4a213f55	fix QB&TR 判重	2023-12-01 08:12:06 +08:00
jxxghp	6a8c684af0	feat 兼容TR下载任务重复添加	2023-11-30 15:58:44 +08:00
jxxghp	aefba83319	fix	2023-11-30 13:35:26 +08:00
jxxghp	e411f4062a	feat 兼容QB下载任务重复添加	2023-11-30 13:14:55 +08:00
jxxghp	3c6802860d	fix #1186	2023-11-30 11:19:43 +08:00
jxxghp	3daad5ea90	Merge pull request #1186 from honue/main	2023-11-30 11:08:00 +08:00
jxxghp	6835c38c24	Merge remote-tracking branch 'origin/main'	2023-11-30 08:16:30 +08:00
honue	32be9b71d5	Merge remote-tracking branch 'origin/main'	2023-11-30 07:42:19 +08:00
honue	84bc0e0fb4	fix	2023-11-30 07:41:58 +08:00
Summer⛱	8105dc9c82	Merge branch 'jxxghp:main' into main	2023-11-30 00:42:23 +08:00
honue	840c968454	tr增加修改tracker方法	2023-11-30 00:39:57 +08:00
honue	8c5f19a0f4	fix	2023-11-30 00:39:35 +08:00
jxxghp	bf813aa906	Merge pull request #1181 from honue/main	2023-11-29 13:29:40 +08:00
honue	e5ac7f10d4	update downloader init	2023-11-29 13:23:28 +08:00
jxxghp	d049e04fa2	v1.4.7	2023-11-29 13:13:58 +08:00
jxxghp	ef45b08ee5	Merge pull request #1180 from honue/main	2023-11-29 13:01:18 +08:00
honue	d77644ab16	fix singleton.py	2023-11-29 12:46:49 +08:00
jxxghp	1a90b4a3cb	v1.4.7	2023-11-29 12:39:37 +08:00
jxxghp	9e5d401a85	remove plugin_color	2023-11-29 12:07:54 +08:00
jxxghp	6da6dc2b8c	Merge pull request #1178 from cikezhu/main	2023-11-29 08:43:26 +08:00
叮叮当	2ca7021df0	fix item_id	2023-11-29 08:35:44 +08:00
jxxghp	1682cdad37	fix README.md	2023-11-28 14:55:05 +08:00
jxxghp	ec5e898feb	fix app.env	2023-11-27 08:36:45 +08:00
jxxghp	ccf6fb1b36	fix 插件重置	2023-11-27 08:30:13 +08:00
jxxghp	83c8d619d0	fix README.md	2023-11-27 08:17:23 +08:00
jxxghp	dd5b8219a1	更新 plugin.py	2023-11-27 07:09:38 +08:00
jxxghp	34fd927972	更新 README.md	2023-11-26 22:50:43 +08:00
jxxghp	6db5ad2697	feat：插件重置	2023-11-26 21:40:43 +08:00
jxxghp	0be1f27970	- 修复了种子失效时订阅一直偿试下载的问题 - 新增配置中心插件，可快速调整配置	2023-11-26 20:16:44 +08:00
jxxghp	54603798fc	fix bug	2023-11-24 15:26:54 +08:00
jxxghp	2f1e947323	fix #1144	2023-11-24 15:24:38 +08:00
jxxghp	ef2cfe1c1d	fix #1141 修复错误种子链接一直偿试下载的问题	2023-11-24 14:32:56 +08:00
jxxghp	f8edf79c59	fix api doc	2023-11-24 14:00:52 +08:00
jxxghp	dec80b6567	fix	2023-11-23 17:25:54 +08:00
jxxghp	4dac9237ef	fix README.md	2023-11-23 17:22:13 +08:00
jxxghp	12f5f373b3	fix frozen	2023-11-23 10:59:33 +08:00
jxxghp	76472770bf	v1.4.5	2023-11-22 15:35:12 +08:00
jxxghp	f5baf77c3c	Merge pull request #1155 from thsrite/main	2023-11-22 13:42:33 +08:00
thsrite	126276c727	fix #1154	2023-11-22 13:39:39 +08:00
jxxghp	5d6ba83fc5	Merge pull request #1153 from thsrite/main	2023-11-22 09:23:19 +08:00
thsrite	047c3b596d	add 插件方法	2023-11-22 09:21:51 +08:00
jxxghp	2240ff08a1	fix 插件事件依赖	2023-11-22 07:25:00 +08:00
jxxghp	4d6bf56fa0	fix bug	2023-11-21 21:44:50 +08:00
jxxghp	10ad9a5601	fix bug	2023-11-21 21:20:02 +08:00
jxxghp	fb39500428	feat 优化插件仓库URL格式	2023-11-21 21:10:34 +08:00
jxxghp	615a52cef9	更新 build.yml	2023-11-20 21:53:38 +08:00
jxxghp	791be0583a	fix build	2023-11-20 20:14:07 +08:00
jxxghp	a324731061	- 优化豆瓣详情展示	2023-11-20 20:06:25 +08:00
jxxghp	539d9cf537	- 优化豆瓣详情展示	2023-11-20 20:01:04 +08:00
jxxghp	699312ff28	- 优化豆瓣详情展示	2023-11-20 19:56:52 +08:00
jxxghp	b92b0ec149	fix build	2023-11-20 19:54:41 +08:00
jxxghp	51536062f1	fix	2023-11-20 16:43:49 +08:00
jxxghp	4c230b4c1e	feat 清理缓存时清理种子缓存	2023-11-20 10:56:28 +08:00
jxxghp	a7752ceb17	fix bug	2023-11-19 09:48:06 +08:00
jxxghp	ed59a90d78	fix update timeout	2023-11-19 09:45:13 +08:00
jxxghp	11d65e7527	fix douban scraper	2023-11-19 09:05:58 +08:00
jxxghp	b6ac5f0f84	feat 完善豆瓣详情API	2023-11-18 22:37:23 +08:00
jxxghp	c336e62885	Merge remote-tracking branch 'origin/main'	2023-11-18 21:54:10 +08:00
jxxghp	b868cdb25e	feat 完善豆瓣详情API	2023-11-18 21:53:58 +08:00
jxxghp	04339539d1	fix bug	2023-11-17 14:25:00 +08:00
jxxghp	2d146880ec	fix	2023-11-17 13:36:23 +08:00
jxxghp	6eec4ef7f4	fix build	2023-11-17 12:27:43 +08:00
jxxghp	9841f3dd18	fix build	2023-11-17 11:43:01 +08:00
jxxghp	03e0118fb7	add linux frozen build	2023-11-17 11:39:03 +08:00
jxxghp	c7c222b357	v1.4.3	2023-11-17 11:12:52 +08:00
jxxghp	2d8e45cd1b	feat TG消息重试	2023-11-17 10:41:14 +08:00
jxxghp	e2bd5cc245	更新 resource.py	2023-11-16 21:10:21 +08:00
jxxghp	47ddfec30e	feat 资源包自动更新	2023-11-16 20:57:41 +08:00
jxxghp	9344b2a324	add AGSVPT	2023-11-16 17:27:58 +08:00
jxxghp	8496fcccc5	Merge pull request #1133 from honue/main	2023-11-16 14:59:50 +08:00
honue	c6fa3b9d25	fix torrent_cache ttl	2023-11-16 13:34:23 +08:00
jxxghp	ce13987748	- 修复Windows打包	2023-11-15 08:20:57 +08:00
jxxghp	5221fc4f6a	fix #1125	2023-11-15 08:08:46 +08:00
jxxghp	d4dc388d3f	fix search	2023-11-14 17:54:41 +08:00
jxxghp	42966c2537	fix #1122	2023-11-14 17:35:31 +08:00
jxxghp	7921dcd86b	Merge pull request #1122 from thsrite/main	2023-11-14 17:30:52 +08:00
thsrite	4c69bb6c48	fix	2023-11-14 16:22:04 +08:00
thsrite	0aad809c82	feat 增加GITHUB_TOKEN，提高API限流阈值	2023-11-14 16:12:02 +08:00
thsrite	f514a5a416	fix `793a7460`	2023-11-14 14:17:14 +08:00
thsrite	793a7460c6	fix 动漫电影剧场版	2023-11-14 14:10:48 +08:00
jxxghp	6dcc979fd5	fix #1072 fix #1118	2023-11-14 08:19:57 +08:00
jxxghp	5a07732712	fix 豆瓣已订阅显示	2023-11-13 20:25:57 +08:00
jxxghp	61d71b32ff	fix 豆瓣已订阅显示	2023-11-13 20:22:51 +08:00