v1.3.4

feat:增加自定义站点配置，仅为统计和签到使用

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -9,8 +9,9 @@ body:
         请确认以下信息：
         1. 请按此模板提交issues，不按模板提交的问题将直接关闭。
         2. 如果你的问题可以直接在以往 issue 或者 Telegram频道 中找到，那么你的 issue 将会被直接关闭。
-        3. 提交问题务必描述清楚、附上日志，描述不清导致无法理解和分析的问题会被直接关闭。
+        3. 【提交问题务必描述清楚、附上日志】，描述不清导致无法理解和分析的问题会被直接关闭。
         4. 此仓库为后端仓库，如果是前端 WebUI 问题请在[前端仓库](https://github.com/jxxghp/MoviePilot-Frontend)提 issue。
+        5. 【不要通过issues来寻求解决你的环境问题、配置安装类问题、咨询类问题】，否则直接关闭并加入用户黑名单！实在没有精力陪一波又一波的伸手党玩。
   - type: checkboxes
     id: ensure
     attributes:

.github/workflows/build.yml

@@ -69,6 +69,7 @@ jobs:
         uses: actions/setup-python@v4
         with:
           python-version: '3.11.4'
+          cache: 'pip'
 
       - name: Install Dependent Packages
         run: |
@@ -149,4 +150,4 @@ jobs:
         with:
           release_id: ${{ steps.create_release.outputs.id }}
           assets_path: |
-            ./releases/
+            ./releases/

Dockerfile

@@ -31,13 +31,14 @@ RUN apt-get update -y \
         dumb-init \
         jq \
         haproxy \
-        rclone \
+        fuse3 \
     && \
     if [ "$(uname -m)" = "x86_64" ]; \
         then ln -s /usr/lib/x86_64-linux-musl/libc.so /lib/libc.musl-x86_64.so.1; \
     elif [ "$(uname -m)" = "aarch64" ]; \
         then ln -s /usr/lib/aarch64-linux-musl/libc.so /lib/libc.musl-aarch64.so.1; \
     fi \
+    && curl https://rclone.org/install.sh | bash \
     && apt-get autoremove -y \
     && apt-get clean -y \
     && rm -rf \

README.md

@@ -51,12 +51,12 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
 
 配置文件映射路径：`/config`，配置项生效优先级：环境变量 > env文件 > 默认值，**部分参数如路径映射、站点认证、权限端口、时区等必须通过环境变量进行配置**。
 
->   $\color{red}{*}$   号标识的为必填项，其它为可选项，可选项可删除配置变量从而使用默认值。
+> ❗号标识的为必填项，其它为可选项，可选项可删除配置变量从而使用默认值。
 
 ### 1. **基础设置**
 
-- **NGINX_PORT $\color{red}{*}$ ：** WEB服务端口，默认`3000`，可自行修改，不能与API服务端口冲突（仅支持环境变量配置）
-- **PORT $\color{red}{*}$ ：** API服务端口，默认`3001`，可自行修改，不能与WEB服务端口冲突（仅支持环境变量配置）
+- **❗NGINX_PORT：** WEB服务端口，默认`3000`，可自行修改，不能与API服务端口冲突（仅支持环境变量配置）
+- **❗PORT：** API服务端口，默认`3001`，可自行修改，不能与WEB服务端口冲突（仅支持环境变量配置）
 - **PUID**：运行程序用户的`uid`，默认`0`（仅支持环境变量配置）
 - **PGID**：运行程序用户的`gid`，默认`0`（仅支持环境变量配置）
 - **UMASK**：掩码权限，默认`000`，可以考虑设置为`022`（仅支持环境变量配置）
@@ -64,9 +64,9 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
 - **MOVIEPILOT_AUTO_UPDATE**：重启更新，`true`/`false`，默认`true` **注意：如果出现网络问题可以配置`PROXY_HOST`**（仅支持环境变量配置）
 - **MOVIEPILOT_AUTO_UPDATE_DEV**：重启时更新到未发布的开发版本代码，`true`/`false`，默认`false`（仅支持环境变量配置）
 ---
-- **SUPERUSER $\color{red}{*}$ ：** 超级管理员用户名，默认`admin`，安装后使用该用户登录后台管理界面
-- **SUPERUSER_PASSWORD $\color{red}{*}$ ：** 超级管理员初始密码，默认`password`，建议修改为复杂密码
-- **API_TOKEN $\color{red}{*}$ ：** API密钥，默认`moviepilot`，在媒体服务器Webhook、微信回调等地址配置中需要加上`?token=`该值，建议修改为复杂字符串
+- **❗SUPERUSER：** 超级管理员用户名，默认`admin`，安装后使用该用户登录后台管理界面
+- **❗SUPERUSER_PASSWORD：** 超级管理员初始密码，默认`password`，建议修改为复杂密码
+- **❗API_TOKEN：** API密钥，默认`moviepilot`，在媒体服务器Webhook、微信回调等地址配置中需要加上`?token=`该值，建议修改为复杂字符串
 - **TMDB_API_DOMAIN：** TMDB API地址，默认`api.themoviedb.org`，也可配置为`api.tmdb.org`或其它中转代理服务地址，能连通即可
 - **TMDB_IMAGE_DOMAIN：** TMDB图片地址，默认`image.tmdb.org`，可配置为其它中转代理以加速TMDB图片显示，如：`static-mdb.v.geilijiasu.com`
 ---
@@ -74,18 +74,18 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
 - **SCRAP_SOURCE：** 刮削元数据及图片使用的数据源，`themoviedb`/`douban`，默认`themoviedb`
 - **SCRAP_FOLLOW_TMDB：** 新增已入库媒体是否跟随TMDB信息变化，`true`/`false`，默认`true`
 ---
-- **TRANSFER_TYPE $\color{red}{*}$ ：** 整理转移方式，支持`link`/`copy`/`move`/`softlink`/`rclone_copy`/`rclone_move`  **注意：在`link`和`softlink`转移方式下，转移后的文件会继承源文件的权限掩码，不受`UMASK`影响；rclone需要自行映射rclone配置目录到容器中或在容器内完成rclone配置，节点名称必须为：`MP`**
-- **LIBRARY_PATH $\color{red}{*}$ ：** 媒体库目录，多个目录使用`,`分隔
+- **❗TRANSFER_TYPE：** 整理转移方式，支持`link`/`copy`/`move`/`softlink`/`rclone_copy`/`rclone_move`  **注意：在`link`和`softlink`转移方式下，转移后的文件会继承源文件的权限掩码，不受`UMASK`影响；rclone需要自行映射rclone配置目录到容器中或在容器内完成rclone配置，节点名称必须为：`MP`**
+- **❗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) 自动在媒体库目录下建立二级目录分类
 ---
-- **COOKIECLOUD_HOST $\color{red}{*}$ ：** CookieCloud服务器地址，格式：`http(s)://ip:port`，不配置默认使用内建服务器`https://movie-pilot.org/cookiecloud`
-- **COOKIECLOUD_KEY $\color{red}{*}$ ：** CookieCloud用户KEY
-- **COOKIECLOUD_PASSWORD $\color{red}{*}$ ：** CookieCloud端对端加密密码
-- **COOKIECLOUD_INTERVAL $\color{red}{*}$ ：** CookieCloud同步间隔（分钟）
-- **USER_AGENT $\color{red}{*}$ ：** CookieCloud保存Cookie对应的浏览器UA，建议配置，设置后可增加连接站点的成功率，同步站点后可以在管理界面中修改
+- **❗COOKIECLOUD_HOST：** CookieCloud服务器地址，格式：`http(s)://ip:port`，不配置默认使用内建服务器`https://movie-pilot.org/cookiecloud`
+- **❗COOKIECLOUD_KEY：** CookieCloud用户KEY
+- **❗COOKIECLOUD_PASSWORD：** CookieCloud端对端加密密码
+- **❗COOKIECLOUD_INTERVAL：** CookieCloud同步间隔（分钟）
+- **❗USER_AGENT：** CookieCloud保存Cookie对应的浏览器UA，建议配置，设置后可增加连接站点的成功率，同步站点后可以在管理界面中修改
 - **OCR_HOST：** OCR识别服务器地址，格式：`http(s)://ip:port`，用于识别站点验证码实现自动登录获取Cookie等，不配置默认使用内建服务器`https://movie-pilot.org`，可使用 [这个镜像](https://hub.docker.com/r/jxxghp/moviepilot-ocr) 自行搭建。
 ---
 - **SUBSCRIBE_MODE：** 订阅模式，`rss`/`spider`，默认`spider`，`rss`模式通过定时刷新RSS来匹配订阅（RSS地址会自动获取，也可手动维护），对站点压力小，同时可设置订阅刷新周期，24小时运行，但订阅和下载通知不能过滤和显示免费，推荐使用rss模式。
@@ -94,7 +94,7 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
 - **SEARCH_SOURCE：** 媒体信息搜索来源，`themoviedb`/`douban`，默认`themoviedb`
 ---
 - **AUTO_DOWNLOAD_USER：** 远程交互搜索时自动择优下载的用户ID，多个用户使用,分割，未设置需要选择资源或者回复`0`
-- **MESSAGER $\color{red}{*}$ ：** 消息通知渠道，支持 `telegram`/`wechat`/`slack`/`synologychat`，开启多个渠道时使用`,`分隔。同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`telegram`
+- **❗MESSAGER：** 消息通知渠道，支持 `telegram`/`wechat`/`slack`/`synologychat`，开启多个渠道时使用`,`分隔。同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`telegram`
 
   - `wechat`设置项：
 
@@ -125,7 +125,7 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
     - **SYNOLOGYCHAT_TOKEN：** SynologyChat机器人`令牌`
 
 ---
-- **DOWNLOAD_PATH $\color{red}{*}$ ：** 下载保存目录，**注意：需要将`moviepilot`及`下载器`的映射路径保持一致**，否则会导致下载文件无法转移
+- **❗DOWNLOAD_PATH：** 下载保存目录，**注意：需要将`moviepilot`及`下载器`的映射路径保持一致**，否则会导致下载文件无法转移
 - **DOWNLOAD_MOVIE_PATH：** 电影下载保存目录路径，不设置则下载到`DOWNLOAD_PATH`
 - **DOWNLOAD_TV_PATH：** 电视剧下载保存目录路径，不设置则下载到`DOWNLOAD_PATH`
 - **DOWNLOAD_ANIME_PATH：** 动漫下载保存目录路径，不设置则下载到`DOWNLOAD_PATH`
@@ -133,7 +133,7 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
 - **DOWNLOAD_SUBTITLE：** 下载站点字幕，`true`/`false`，默认`true`
 - **DOWNLOADER_MONITOR：** 下载器监控，`true`/`false`，默认为`true`，开启后下载完成时才会自动整理入库
 - **TORRENT_TAG：** 下载器种子标签，默认为`MOVIEPILOT`，设置后只有MoviePilot添加的下载才会处理，留空所有下载器中的任务均会处理
-- **DOWNLOADER $\color{red}{*}$ ：** 下载器，支持`qbittorrent`/`transmission`，QB版本号要求>= 4.3.9，TR版本号要求>= 3.0，同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`qbittorrent`
+- **❗DOWNLOADER：** 下载器，支持`qbittorrent`/`transmission`，QB版本号要求>= 4.3.9，TR版本号要求>= 3.0，同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`qbittorrent`
 
   - `qbittorrent`设置项：
 
@@ -150,7 +150,7 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
 
 ---
 - **REFRESH_MEDIASERVER：** 入库后是否刷新媒体服务器，`true`/`false`，默认`true`
-- **MEDIASERVER $\color{red}{*}$ ：** 媒体服务器，支持`emby`/`jellyfin`/`plex`，同时开启多个使用`,`分隔。还需要配置对应媒体服务器的环境变量，非对应媒体服务器的变量可删除，推荐使用`emby`
+- **❗MEDIASERVER：** 媒体服务器，支持`emby`/`jellyfin`/`plex`，同时开启多个使用`,`分隔。还需要配置对应媒体服务器的环境变量，非对应媒体服务器的变量可删除，推荐使用`emby`
 
   - `emby`设置项：
 
@@ -175,7 +175,7 @@ MoviePilot需要配套下载器和媒体服务器配合使用。
 
 `MoviePilot`需要认证后才能使用，配置`AUTH_SITE`后，需要根据下表配置对应站点的认证参数（**仅能通过环境变量配置**）
 
-- **AUTH_SITE $\color{red}{*}$ ：** 认证站点，支持`iyuu`/`hhclub`/`audiences`/`hddolby`/`zmpt`/`freefarm`/`hdfans`/`wintersakura`/`leaves`/`1ptba`/`icc2022`/`ptlsp`/`xingtan`
+- **❗AUTH_SITE：** 认证站点，支持`iyuu`/`hhclub`/`audiences`/`hddolby`/`zmpt`/`freefarm`/`hdfans`/`wintersakura`/`leaves`/`1ptba`/`icc2022`/`ptlsp`/`xingtan`
 
 |      站点      |                          参数                           |
 |:------------:|:-----------------------------------------------------:|

app/api/endpoints/history.py

@@ -11,7 +11,6 @@ from app.core.security import verify_token
 from app.db import get_db
 from app.db.models.downloadhistory import DownloadHistory
 from app.db.models.transferhistory import TransferHistory
-from app.schemas import MediaType
 from app.schemas.types import EventType
 
 router = APIRouter()
@@ -90,23 +89,3 @@ def delete_transfer_history(history_in: schemas.TransferHistory,
     # 删除记录
     TransferHistory.delete(db, history_in.id)
     return schemas.Response(success=True)
-
-
-@router.post("/transfer", summary="历史记录重新转移", response_model=schemas.Response)
-def redo_transfer_history(history_in: schemas.TransferHistory,
-                          mtype: str = None,
-                          new_tmdbid: int = None,
-                          db: Session = Depends(get_db),
-                          _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    历史记录重新转移，不输入 mtype 和 new_tmdbid 时，自动使用文件名重新识别
-    """
-    if mtype and new_tmdbid:
-        state, errmsg = TransferChain(db).re_transfer(logid=history_in.id,
-                                                      mtype=MediaType(mtype), tmdbid=new_tmdbid)
-    else:
-        state, errmsg = TransferChain(db).re_transfer(logid=history_in.id)
-    if state:
-        return schemas.Response(success=True)
-    else:
-        return schemas.Response(success=False, message=errmsg)

app/api/endpoints/transfer.py

@@ -8,13 +8,15 @@ from app import schemas
 from app.chain.transfer import TransferChain
 from app.core.security import verify_token
 from app.db import get_db
+from app.db.models.transferhistory import TransferHistory
 from app.schemas import MediaType
 
 router = APIRouter()
 
 
 @router.post("/manual", summary="手动转移", response_model=schemas.Response)
-def manual_transfer(path: str,
+def manual_transfer(path: str = None,
+                    logid: int = None,
                     target: str = None,
                     tmdbid: int = None,
                     type_name: str = None,
@@ -28,8 +30,9 @@ def manual_transfer(path: str,
                     db: Session = Depends(get_db),
                     _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
-    手动转移，支持自定义剧集识别格式
+    手动转移，文件或历史记录，支持自定义剧集识别格式
     :param path: 转移路径或文件
+    :param logid: 转移历史记录ID
     :param target: 目标路径
     :param type_name: 媒体类型、电影/电视剧
     :param tmdbid: tmdbid
@@ -43,11 +46,30 @@ def manual_transfer(path: str,
     :param db: 数据库
     :param _: Token校验
     """
-    in_path = Path(path)
+    force = False
+    if logid:
+        # 查询历史记录
+        history = TransferHistory.get(db, logid)
+        if not history:
+            return schemas.Response(success=False, message=f"历史记录不存在，ID：{logid}")
+        # 强制转移
+        force = True
+        # 源路径
+        in_path = Path(history.src)
+        # 目的路径
+        if history.dest:
+            # 删除旧的已整理文件
+            TransferChain(db).delete_files(Path(history.dest))
+            if not target:
+                target = history.dest
+    elif path:
+        in_path = Path(path)
+    else:
+        return schemas.Response(success=False, message=f"缺少参数：path/logid")
+
     if target:
         target = Path(target)
-        if not target.exists():
-            return schemas.Response(success=False, message=f"目标路径不存在")
+
     # 类型
     mtype = MediaType(type_name) if type_name else None
     # 自定义格式
@@ -68,7 +90,8 @@ def manual_transfer(path: str,
         season=season,
         transfer_type=transfer_type,
         epformat=epformat,
-        min_filesize=min_filesize
+        min_filesize=min_filesize,
+        force=force
     )
     # 失败
     if not state:

app/chain/__init__.py

@@ -398,14 +398,15 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("post_torrents_message", message=message, torrents=torrents)
 
-    def scrape_metadata(self, path: Path, mediainfo: MediaInfo) -> None:
+    def scrape_metadata(self, path: Path, mediainfo: MediaInfo, transfer_type: str) -> None:
         """
         刮削元数据
         :param path: 媒体文件路径
         :param mediainfo:  识别的媒体信息
+        :param transfer_type:  转移模式
         :return: 成功或失败
         """
-        self.run_module("scrape_metadata", path=path, mediainfo=mediainfo)
+        self.run_module("scrape_metadata", path=path, mediainfo=mediainfo, transfer_type=transfer_type)
 
     def register_commands(self, commands: Dict[str, dict]) -> None:
         """

app/chain/download.py

@@ -786,6 +786,7 @@ class DownloadChain(ChainBase):
         for torrent in torrents:
             history = self.downloadhis.get_by_hash(torrent.hash)
             if history:
+                # 媒体信息
                 torrent.media = {
                     "tmdbid": history.tmdbid,
                     "type": history.type,
@@ -794,6 +795,8 @@ class DownloadChain(ChainBase):
                     "episode": history.episodes,
                     "image": history.image,
                 }
+                # 下载用户
+                torrent.userid = history.userid
             ret_torrents.append(torrent)
         return ret_torrents
 

app/chain/message.py

@@ -111,7 +111,8 @@ class MessageChain(ChainBase):
                         f"第 {sea} 季缺失 {StringUtils.str_series(no_exist.episodes) if no_exist.episodes else no_exist.total_episode} 集"
                         for sea, no_exist in no_exists.get(mediainfo.tmdb_id).items()]
                     self.post_message(Notification(channel=channel,
-                                                   title=f"{mediainfo.title_year}：\n" + "\n".join(messages)))
+                                                   title=f"{mediainfo.title_year}：\n" + "\n".join(messages),
+                                                   userid=userid))
                 # 搜索种子，过滤掉不需要的剧集，以便选择
                 logger.info(f"{mediainfo.title_year} 媒体库中不存在，开始搜索 ...")
                 self.post_message(

app/chain/search.py

@@ -141,7 +141,7 @@ class SearchChain(ChainBase):
             if not torrents:
                 logger.warn(f'{keyword or mediainfo.title} 没有符合优先级规则的资源')
                 return []
-        # 使用默认过滤规则再次过滤
+        # 使用过滤规则再次过滤
         torrents = self.filter_torrents_by_rule(torrents=torrents,
                                                 filter_rule=filter_rule)
         if not torrents:
@@ -333,9 +333,9 @@ class SearchChain(ChainBase):
         :param filter_rule: 过滤规则
         """
 
-        # 取默认过滤规则
         if not filter_rule:
-            filter_rule = self.systemconfig.get(SystemConfigKey.DefaultFilterRules)
+            # 没有则取搜索默认过滤规则
+            filter_rule = self.systemconfig.get(SystemConfigKey.DefaultSearchFilterRules)
         if not filter_rule:
             return torrents
         # 包含

app/chain/subscribe.py

@@ -244,17 +244,8 @@ class SubscribeChain(ChainBase):
             else:
                 priority_rule = self.systemconfig.get(SystemConfigKey.SubscribeFilterRules)
 
-            # 默认过滤规则
-            if subscribe.include or subscribe.exclude:
-                filter_rule = {
-                    "include": subscribe.include,
-                    "exclude": subscribe.exclude,
-                    "quality": subscribe.quality,
-                    "resolution": subscribe.resolution,
-                    "effect": subscribe.effect,
-                }
-            else:
-                filter_rule = self.systemconfig.get(SystemConfigKey.DefaultFilterRules)
+            # 过滤规则
+            filter_rule = self.get_filter_rule(subscribe)
 
             # 搜索，同时电视剧会过滤掉不需要的剧集
             contexts = self.searchchain.process(mediainfo=mediainfo,
@@ -400,6 +391,67 @@ class SubscribeChain(ChainBase):
 
         return ret_sites
 
+    def get_filter_rule(self, subscribe: Subscribe):
+        """
+        获取订阅过滤规则，没有则返回默认规则
+        """
+        # 默认过滤规则
+        if (subscribe.include
+                or subscribe.exclude
+                or subscribe.quality
+                or subscribe.resolution
+                or subscribe.effect):
+            return {
+                "include": subscribe.include,
+                "exclude": subscribe.exclude,
+                "quality": subscribe.quality,
+                "resolution": subscribe.resolution,
+                "effect": subscribe.effect,
+            }
+        # 订阅默认过滤规则
+        return self.systemconfig.get(SystemConfigKey.DefaultFilterRules) or {}
+    
+    @staticmethod
+    def check_filter_rule(torrent_info: TorrentInfo, filter_rule: Dict[str, str]) -> bool:
+        """
+        检查种子是否匹配订阅过滤规则
+        """
+        if not filter_rule:
+            return True
+        # 包含
+        include = filter_rule.get("include")
+        if include:
+            if not re.search(r"%s" % include,
+                             f"{torrent_info.title} {torrent_info.description}", re.I):
+                logger.info(f"{torrent_info.title} 不匹配包含规则 {include}")
+                return False
+        # 排除
+        exclude = filter_rule.get("exclude")
+        if exclude:
+            if re.search(r"%s" % exclude,
+                         f"{torrent_info.title} {torrent_info.description}", re.I):
+                logger.info(f"{torrent_info.title} 匹配排除规则 {exclude}")
+                return False
+        # 质量
+        quality = filter_rule.get("quality")
+        if quality:
+            if not re.search(r"%s" % quality, torrent_info.title, re.I):
+                logger.info(f"{torrent_info.title} 不匹配质量规则 {quality}")
+                return False
+        # 分辨率
+        resolution = filter_rule.get("resolution")
+        if resolution:
+            if not re.search(r"%s" % resolution, torrent_info.title, re.I):
+                logger.info(f"{torrent_info.title} 不匹配分辨率规则 {resolution}")
+                return False
+        # 特效
+        effect = filter_rule.get("effect")
+        if effect:
+            if not re.search(r"%s" % effect, torrent_info.title, re.I):
+                logger.info(f"{torrent_info.title} 不匹配特效规则 {effect}")
+                return False
+        return True
+
     def match(self, torrents: Dict[str, List[Context]]):
         """
         从缓存中匹配订阅，并自动下载
@@ -475,10 +527,8 @@ class SubscribeChain(ChainBase):
                     if no_exists_info:
                         logger.info(f'订阅 {mediainfo.title_year} {meta.season} 缺失集：{no_exists_info.episodes}')
 
-            # 默认过滤规则
-            default_filter = self.systemconfig.get(SystemConfigKey.DefaultFilterRules) or {}
-            include = subscribe.include or default_filter.get("include")
-            exclude = subscribe.exclude or default_filter.get("exclude")
+            # 过滤规则
+            filter_rule = self.get_filter_rule(subscribe)
 
             # 遍历缓存种子
             _match_context = []
@@ -494,11 +544,11 @@ class SubscribeChain(ChainBase):
                         continue
                     # 优先级过滤规则
                     if subscribe.best_version:
-                        filter_rule = self.systemconfig.get(SystemConfigKey.BestVersionFilterRules)
+                        priority_rule = self.systemconfig.get(SystemConfigKey.BestVersionFilterRules)
                     else:
-                        filter_rule = self.systemconfig.get(SystemConfigKey.SubscribeFilterRules)
+                        priority_rule = self.systemconfig.get(SystemConfigKey.SubscribeFilterRules)
                     result: List[TorrentInfo] = self.filter_torrents(
-                        rule_string=filter_rule,
+                        rule_string=priority_rule,
                         torrent_list=[torrent_info],
                         mediainfo=torrent_mediainfo)
                     if result is not None and not result:
@@ -539,7 +589,8 @@ class SubscribeChain(ChainBase):
                                                 set(torrent_meta.episode_list)
                                             ):
                                         logger.info(
-                                            f'{torrent_info.title} 对应剧集 {torrent_meta.episode_list} 未包含缺失的剧集')
+                                            f'{torrent_info.title} 对应剧集 {torrent_meta.episode_list} 未包含缺失的剧集'
+                                        )
                                         continue
                             # 过滤掉已经下载的集数
                             if self.__check_subscribe_note(subscribe, torrent_meta.episode_list):
@@ -551,18 +602,12 @@ class SubscribeChain(ChainBase):
                                 if torrent_meta.episode_list:
                                     logger.info(f'{subscribe.name} 正在洗版，{torrent_info.title} 不是整季')
                                     continue
-                    # 包含
-                    if include:
-                        if not re.search(r"%s" % include,
-                                         f"{torrent_info.title} {torrent_info.description}", re.I):
-                            logger.info(f"{torrent_info.title} 不匹配包含规则 {include}")
-                            continue
-                    # 排除
-                    if exclude:
-                        if re.search(r"%s" % exclude,
-                                     f"{torrent_info.title} {torrent_info.description}", re.I):
-                            logger.info(f"{torrent_info.title} 匹配排除规则 {exclude}")
-                            continue
+
+                    # 过滤规则
+                    if not self.check_filter_rule(torrent_info=torrent_info,
+                                                  filter_rule=filter_rule):
+                        continue
+
                     # 匹配成功
                     logger.info(f'{mediainfo.title_year} 匹配成功：{torrent_info.title}')
                     _match_context.append(context)

app/chain/system.py

@@ -2,12 +2,14 @@ from typing import Union
 
 from app.chain import ChainBase
 from app.schemas import Notification, MessageChannel
+from app.utils.system import SystemUtils
 
 
 class SystemChain(ChainBase):
     """
     系统级处理链
     """
+
     def remote_clear_cache(self, channel: MessageChannel, userid: Union[int, str]):
         """
         清理系统缓存
@@ -15,3 +17,11 @@ class SystemChain(ChainBase):
         self.clear_cache()
         self.post_message(Notification(channel=channel,
                                        title=f"缓存清理完成！", userid=userid))
+
+    def restart(self, channel: MessageChannel, userid: Union[int, str]):
+        """
+        重启系统
+        """
+        self.post_message(Notification(channel=channel,
+                                       title=f"系统正在重启，请耐心等候！", userid=userid))
+        SystemUtils.restart()

app/chain/transfer.py

@@ -1,4 +1,3 @@
-import glob
 import re
 import shutil
 import threading
@@ -237,7 +236,7 @@ class TransferChain(ChainBase):
                 # 自定义识别
                 if formaterHandler:
                     # 开始集、结束集、PART
-                    begin_ep, end_ep, part = formaterHandler.split_episode(file_path.stem)
+                    begin_ep, end_ep, part = formaterHandler.split_episode(file_path.name)
                     if begin_ep is not None:
                         file_meta.begin_episode = begin_ep
                         file_meta.part = part
@@ -358,7 +357,9 @@ class TransferChain(ChainBase):
                 )
                 # 刮削单个文件
                 if settings.SCRAP_METADATA:
-                    self.scrape_metadata(path=transferinfo.target_path, mediainfo=file_mediainfo)
+                    self.scrape_metadata(path=transferinfo.target_path,
+                                         mediainfo=file_mediainfo,
+                                         transfer_type=transfer_type)
                 # 更新进度
                 processed_num += 1
                 self.progress.update(value=processed_num / total_num * 100,
@@ -489,7 +490,7 @@ class TransferChain(ChainBase):
     def re_transfer(self, logid: int,
                     mtype: MediaType = None, tmdbid: int = None) -> Tuple[bool, str]:
         """
-        根据历史记录，重新识别转移，只处理对应的src目录
+        根据历史记录，重新识别转移，只支持简单条件
         :param logid: 历史记录ID
         :param mtype: 媒体类型
         :param tmdbid: TMDB ID
@@ -499,7 +500,7 @@ class TransferChain(ChainBase):
         if not history:
             logger.error(f"历史记录不存在，ID：{logid}")
             return False, "历史记录不存在"
-        # 没有下载记录，按源目录路径重新转移
+        # 按源目录路径重新转移
         src_path = Path(history.src)
         if not src_path.exists():
             return False, f"源目录不存在：{src_path}"
@@ -539,9 +540,10 @@ class TransferChain(ChainBase):
                         season: int = None,
                         transfer_type: str = None,
                         epformat: EpisodeFormat = None,
-                        min_filesize: int = 0) -> Tuple[bool, Union[str, list]]:
+                        min_filesize: int = 0,
+                        force: bool = False) -> Tuple[bool, Union[str, list]]:
         """
-        手动转移
+        手动转移，支持复杂条件，带进度显示
         :param in_path: 源文件路径
         :param target: 目标路径
         :param tmdbid: TMDB ID
@@ -550,6 +552,7 @@ class TransferChain(ChainBase):
         :param transfer_type: 转移类型
         :param epformat: 剧集格式
         :param min_filesize: 最小文件大小(MB)
+        :param force: 是否强制转移
         """
         logger.info(f"手动转移：{in_path} ...")
 
@@ -571,7 +574,8 @@ class TransferChain(ChainBase):
                 target=target,
                 season=season,
                 epformat=epformat,
-                min_filesize=min_filesize
+                min_filesize=min_filesize,
+                force=force
             )
             if not state:
                 return False, errmsg
@@ -586,7 +590,8 @@ class TransferChain(ChainBase):
                                              transfer_type=transfer_type,
                                              season=season,
                                              epformat=epformat,
-                                             min_filesize=min_filesize)
+                                             min_filesize=min_filesize,
+                                             force=force)
             return state, errmsg
 
     def send_transfer_message(self, meta: MetaBase, mediainfo: MediaInfo,

app/command.py

@@ -19,7 +19,6 @@ from app.schemas import Notification
 from app.schemas.types import EventType, MessageChannel
 from app.utils.object import ObjectUtils
 from app.utils.singleton import Singleton
-from app.utils.system import SystemUtils
 
 
 class CommandChian(ChainBase):
@@ -139,7 +138,7 @@ class Command(metaclass=Singleton):
                 "data": {}
             },
             "/restart": {
-                "func": SystemUtils.restart,
+                "func": SystemChain(self._db).restart,
                 "description": "重启系统",
                 "category": "管理",
                 "data": {}

app/log.py

@@ -1,28 +1,12 @@
 import logging
 from logging.handlers import RotatingFileHandler
+from pathlib import Path
 
 import click
 
 from app.core.config import settings
 
-# logger
-logger = logging.getLogger()
-if settings.DEBUG:
-    logger.setLevel(logging.DEBUG)
-else:
-    logger.setLevel(logging.INFO)
-
-# 创建终端输出Handler
-console_handler = logging.StreamHandler()
-console_handler.setLevel(logging.DEBUG)
-
-# 创建文件输出Handler
-file_handler = RotatingFileHandler(filename=settings.LOG_PATH / 'moviepilot.log',
-                                   mode='w',
-                                   maxBytes=5 * 1024 * 1024,
-                                   backupCount=3,
-                                   encoding='utf-8')
-file_handler.setLevel(logging.INFO)
+# 日志级别颜色
 level_name_colors = {
     logging.DEBUG: lambda level_name: click.style(str(level_name), fg="cyan"),
     logging.INFO: lambda level_name: click.style(str(level_name), fg="green"),
@@ -34,20 +18,40 @@ level_name_colors = {
 }
 
 
-# 定义日志输出格式
 class CustomFormatter(logging.Formatter):
+    """
+    定义日志输出格式
+    """
+
     def format(self, record):
         seperator = " " * (8 - len(record.levelname))
         record.leveltext = level_name_colors[record.levelno](record.levelname + ":") + seperator
+        if record.filename == "__init__.py":
+            record.filename = Path(record.pathname).parent.name
         return super().format(record)
 
 
+# DEBUG
+logger = logging.getLogger()
+if settings.DEBUG:
+    logger.setLevel(logging.DEBUG)
+else:
+    logger.setLevel(logging.INFO)
+
 # 终端日志
+console_handler = logging.StreamHandler()
+console_handler.setLevel(logging.DEBUG)
 console_formatter = CustomFormatter("%(leveltext)s%(filename)s - %(message)s")
 console_handler.setFormatter(console_formatter)
 logger.addHandler(console_handler)
 
 # 文件日志
+file_handler = RotatingFileHandler(filename=settings.LOG_PATH / 'moviepilot.log',
+                                   mode='w',
+                                   maxBytes=5 * 1024 * 1024,
+                                   backupCount=3,
+                                   encoding='utf-8')
+file_handler.setLevel(logging.INFO)
 file_formater = CustomFormatter("【%(levelname)s】%(asctime)s - %(filename)s - %(message)s")
 file_handler.setFormatter(file_formater)
 logger.addHandler(file_handler)

app/main.py

@@ -2,7 +2,6 @@ import multiprocessing
 import os
 import sys
 import threading
-from pathlib import Path
 
 import uvicorn as uvicorn
 from PIL import Image

app/modules/douban/__init__.py

@@ -1,3 +1,4 @@
+import re
 from pathlib import Path
 from typing import List, Optional, Tuple, Union
 
@@ -420,9 +421,14 @@ class DoubanModule(_ModuleBase):
             logger.info(f"开始使用IMDBID {imdbid} 查询豆瓣信息 ...")
             result = self.doubanapi.imdbid(imdbid)
             if result:
+                doubanid = result.get("id")
+                if doubanid and not str(doubanid).isdigit():
+                    doubanid = re.search(r"\d+", doubanid).group(0)
+                    result["id"] = doubanid
+                logger.info(f"{imdbid} 查询到豆瓣信息：{result.get('title')}")
                 return result
         # 搜索
-        logger.info(f"开始使用名称 {name} 查询豆瓣信息 ...")
+        logger.info(f"开始使用名称 {name} 匹配豆瓣信息 ...")
         result = self.doubanapi.search(f"{name} {year or ''}".strip())
         if not result:
             logger.warn(f"未找到 {name} 的豆瓣信息")
@@ -450,6 +456,7 @@ class DoubanModule(_ModuleBase):
             if meta.name == name \
                     and ((not season and not meta.begin_season) or meta.begin_season == season) \
                     and (not year or item.get('year') == year):
+                logger.info(f"{name} 匹配到豆瓣信息：{item.get('id')} {item.get('title')}")
                 return item
         return {}
 
@@ -463,11 +470,12 @@ class DoubanModule(_ModuleBase):
             return []
         return infos.get("subject_collection_items")
 
-    def scrape_metadata(self, path: Path, mediainfo: MediaInfo) -> None:
+    def scrape_metadata(self, path: Path, mediainfo: MediaInfo, transfer_type: str) -> None:
         """
         刮削元数据
         :param path: 媒体文件路径
         :param mediainfo:  识别的媒体信息
+        :param transfer_type: 传输类型
         :return: 成功或失败
         """
         if settings.SCRAP_SOURCE != "douban":
@@ -487,10 +495,14 @@ class DoubanModule(_ModuleBase):
             if not doubaninfo:
                 logger.warn(f"未找到 {mediainfo.title} 的豆瓣信息")
                 return
+            # 查询豆瓣详情
+            doubaninfo = self.douban_info(doubaninfo.get("id"))
+            # 刮削路径
             scrape_path = path / path.name
             self.scraper.gen_scraper_files(meta=meta,
                                            mediainfo=MediaInfo(douban_info=doubaninfo),
-                                           file_path=scrape_path)
+                                           file_path=scrape_path,
+                                           transfer_type=transfer_type)
         else:
             # 目录下的所有文件
             for file in SystemUtils.list_files(path, settings.RMT_MEDIAEXT):
@@ -510,10 +522,13 @@ class DoubanModule(_ModuleBase):
                     if not doubaninfo:
                         logger.warn(f"未找到 {mediainfo.title} 的豆瓣信息")
                         break
+                    # 查询豆瓣详情
+                    doubaninfo = self.douban_info(doubaninfo.get("id"))
                     # 刮削
                     self.scraper.gen_scraper_files(meta=meta,
                                                    mediainfo=MediaInfo(douban_info=doubaninfo),
-                                                   file_path=file)
+                                                   file_path=file,
+                                                   transfer_type=transfer_type)
                 except Exception as e:
                     logger.error(f"刮削文件 {file} 失败，原因：{e}")
         logger.info(f"{path} 刮削完成")

app/modules/douban/scraper.py

@@ -1,25 +1,34 @@
 import time
 from pathlib import Path
+from typing import Union
 from xml.dom import minidom
 
+from app.core.config import settings
 from app.core.context import MediaInfo
 from app.core.meta import MetaBase
 from app.log import logger
 from app.schemas.types import MediaType
 from app.utils.dom import DomUtils
 from app.utils.http import RequestUtils
+from app.utils.system import SystemUtils
 
 
 class DoubanScraper:
 
-    def gen_scraper_files(self, meta: MetaBase, mediainfo: MediaInfo, file_path: Path):
+    _transfer_type = settings.TRANSFER_TYPE
+
+    def gen_scraper_files(self, meta: MetaBase, mediainfo: MediaInfo,
+                          file_path: Path, transfer_type: str):
         """
         生成刮削文件
         :param meta: 元数据
         :param mediainfo: 媒体信息
         :param file_path: 文件路径或者目录路径
+        :param transfer_type: 转输类型
         """
 
+        self._transfer_type = transfer_type
+
         try:
             # 电影
             if mediainfo.type == MediaType.MOVIE:
@@ -154,8 +163,7 @@ class DoubanScraper:
         # 保存
         self.__save_nfo(doc, season_path.joinpath("season.nfo"))
 
-    @staticmethod
-    def __save_image(url: str, file_path: Path):
+    def __save_image(self, url: str, file_path: Path):
         """
         下载图片并保存
         """
@@ -171,20 +179,39 @@ class DoubanScraper:
             logger.info(f"正在下载{file_path.stem}图片：{url} ...")
             r = RequestUtils().get_res(url=url)
             if r:
-                file_path.write_bytes(r.content)
+                if self._transfer_type in ['rclone_move', 'rclone_copy']:
+                    self.__save_remove_file(file_path, r.content)
+                else:
+                    file_path.write_bytes(r.content)
                 logger.info(f"图片已保存：{file_path}")
             else:
                 logger.info(f"{file_path.stem}图片下载失败，请检查网络连通性")
         except Exception as err:
             logger.error(f"{file_path.stem}图片下载失败：{err}")
 
-    @staticmethod
-    def __save_nfo(doc, file_path: Path):
+    def __save_nfo(self, doc, file_path: Path):
         """
         保存NFO
         """
         if file_path.exists():
             return
         xml_str = doc.toprettyxml(indent="  ", encoding="utf-8")
-        file_path.write_bytes(xml_str)
+        if self._transfer_type in ['rclone_move', 'rclone_copy']:
+            self.__save_remove_file(file_path, xml_str)
+        else:
+            file_path.write_bytes(xml_str)
         logger.info(f"NFO文件已保存：{file_path}")
+
+    def __save_remove_file(self, out_file: Path, content: Union[str, bytes]):
+        """
+        保存文件到远端
+        """
+        temp_file = settings.TEMP_PATH / str(out_file)[1:]
+        temp_file_dir = temp_file.parent
+        if not temp_file_dir.exists():
+            temp_file_dir.mkdir(parents=True, exist_ok=True)
+        temp_file.write_bytes(content)
+        if self._transfer_type == 'rclone_move':
+            SystemUtils.rclone_move(temp_file, out_file)
+        elif self._transfer_type == 'rclone_copy':
+            SystemUtils.rclone_copy(temp_file, out_file)

app/modules/emby/emby.py

@@ -800,7 +800,7 @@ class Emby(metaclass=Singleton):
         eventType = message.get('Event')
         if not eventType:
             return None
-        logger.info(f"接收到emby webhook：{message}")
+        logger.debug(f"接收到emby webhook：{message}")
         eventItem = schemas.WebhookEventInfo(event=eventType, channel="emby")
         if message.get('Item'):
             if message.get('Item', {}).get('Type') == 'Episode':

app/modules/filetransfer/__init__.py

@@ -45,7 +45,8 @@ class FileTransferModule(_ModuleBase):
         # 获取目标路径
         if not target:
             target = self.get_target_path(in_path=path)
-        else:
+        elif not target.exists() or target.is_file():
+            # 目的路径不存在或者是文件时，找对应的媒体库目录
             target = self.get_library_path(target)
         if not target:
             logger.error("未找到媒体库目录，无法转移文件")
@@ -388,8 +389,9 @@ class FileTransferModule(_ModuleBase):
                 return TransferInfo(success=False,
                                     path=in_path,
                                     message=f"{target_dir} 目标路径不存在")
-            # 媒体库目的目录
-            target_dir = self.__get_dest_dir(mediainfo=mediainfo, target_dir=target_dir)
+
+        # 媒体库目的目录
+        target_dir = self.__get_dest_dir(mediainfo=mediainfo, target_dir=target_dir)
 
         # 重命名格式
         rename_format = settings.TV_RENAME_FORMAT \
@@ -402,6 +404,8 @@ class FileTransferModule(_ModuleBase):
             bluray_flag = SystemUtils.is_bluray_dir(in_path)
             if bluray_flag:
                 logger.info(f"{in_path} 是蓝光原盘文件夹")
+            # 原文件大小
+            file_size = in_path.stat().st_size
             # 目的路径
             new_path = self.get_rename_path(
                 path=target_dir,
@@ -426,7 +430,7 @@ class FileTransferModule(_ModuleBase):
             return TransferInfo(success=True,
                                 path=in_path,
                                 target_path=new_path,
-                                total_size=new_path.stat().st_size,
+                                total_size=file_size,
                                 is_bluray=bluray_flag)
         else:
             # 转移单个文件
@@ -467,7 +471,8 @@ class FileTransferModule(_ModuleBase):
                 if new_file.stat().st_size < in_path.stat().st_size:
                     logger.info(f"目标文件已存在，但文件大小更小，将覆盖：{new_file}")
                     overflag = True
-
+            # 原文件大小
+            file_size = in_path.stat().st_size
             # 转移文件
             retcode = self.__transfer_file(file_item=in_path,
                                            new_file=new_file,
@@ -486,7 +491,7 @@ class FileTransferModule(_ModuleBase):
                                 path=in_path,
                                 target_path=new_file,
                                 file_count=1,
-                                total_size=new_file.stat().st_size,
+                                total_size=file_size,
                                 is_bluray=False,
                                 file_list=[str(in_path)],
                                 file_list_new=[str(new_file)])
@@ -572,7 +577,7 @@ class FileTransferModule(_ModuleBase):
     @staticmethod
     def get_library_path(path: Path):
         """
-        根据目录查询其所在的媒体库目录，查询不到的返回输入目录
+        根据文件路径查询其所在的媒体库目录，查询不到的返回输入目录
         """
         if not path:
             return None

app/modules/filter/__init__.py

@@ -85,6 +85,11 @@ class FilterModule(_ModuleBase):
             "include": [r"[\s.]+HDR[\s.]+|HDR10|HDR10\+"],
             "exclude": []
         },
+        # SDR
+        "SDR": {
+            "include": [r"[\s.]+SDR[\s.]+"],
+            "exclude": []
+        },
         # 重编码
         "REMUX": {
             "include": [r'REMUX'],
@@ -104,11 +109,21 @@ class FilterModule(_ModuleBase):
             "include": [r'[国國][语語]配音|[国國]配|[国國][语語]'],
             "exclude": []
         },
+        # 粤语配音
+        "HKVOI": {
+            "include": [r'粤语配音|粤语'],
+            "exclude": []
+        },
         # 60FPS
         "60FPS": {
             "include": [r'60fps'],
             "exclude": []
         },
+        # 3D
+        "3D": {
+            "include": [r'3D'],
+            "exclude": []
+        },
     }
 
     def init_module(self) -> None:

app/modules/jellyfin/jellyfin.py

@@ -452,7 +452,7 @@ class Jellyfin(metaclass=Singleton):
             return None
         if not message:
             return None
-        logger.info(f"接收到jellyfin webhook：{message}")
+        logger.debug(f"接收到jellyfin webhook：{message}")
         eventType = message.get('NotificationType')
         if not eventType:
             return None

app/modules/plex/plex.py

@@ -492,7 +492,7 @@ class Plex(metaclass=Singleton):
         eventType = message.get('event')
         if not eventType:
             return None
-        logger.info(f"接收到plex webhook：{message}")
+        logger.debug(f"接收到plex webhook：{message}")
         eventItem = schemas.WebhookEventInfo(event=eventType, channel="plex")
         if message.get('Metadata'):
             if message.get('Metadata', {}).get('type') == 'episode':

app/modules/themoviedb/__init__.py

@@ -187,11 +187,12 @@ class TheMovieDbModule(_ModuleBase):
 
         return [MediaInfo(tmdb_info=info) for info in results]
 
-    def scrape_metadata(self, path: Path, mediainfo: MediaInfo) -> None:
+    def scrape_metadata(self, path: Path, mediainfo: MediaInfo, transfer_type: str) -> None:
         """
         刮削元数据
         :param path: 媒体文件路径
         :param mediainfo:  识别的媒体信息
+        :param transfer_type:  转移类型
         :return: 成功或失败
         """
         if settings.SCRAP_SOURCE != "themoviedb":
@@ -202,12 +203,14 @@ class TheMovieDbModule(_ModuleBase):
             logger.info(f"开始刮削蓝光原盘：{path} ...")
             scrape_path = path / path.name
             self.scraper.gen_scraper_files(mediainfo=mediainfo,
-                                           file_path=scrape_path)
+                                           file_path=scrape_path,
+                                           transfer_type=transfer_type)
         elif path.is_file():
             # 单个文件
             logger.info(f"开始刮削媒体库文件：{path} ...")
             self.scraper.gen_scraper_files(mediainfo=mediainfo,
-                                           file_path=path)
+                                           file_path=path,
+                                           transfer_type=transfer_type)
         else:
             # 目录下的所有文件
             logger.info(f"开始刮削目录：{path} ...")
@@ -215,7 +218,8 @@ class TheMovieDbModule(_ModuleBase):
                 if not file:
                     continue
                 self.scraper.gen_scraper_files(mediainfo=mediainfo,
-                                               file_path=file)
+                                               file_path=file,
+                                               transfer_type=transfer_type)
         logger.info(f"{path} 刮削完成")
 
     def tmdb_discover(self, mtype: MediaType, sort_by: str, with_genres: str, with_original_language: str,

app/modules/themoviedb/scraper.py

@@ -1,5 +1,6 @@
 import time
 from pathlib import Path
+from typing import Union
 from xml.dom import minidom
 
 from requests import RequestException
@@ -12,21 +13,26 @@ from app.schemas.types import MediaType
 from app.utils.common import retry
 from app.utils.dom import DomUtils
 from app.utils.http import RequestUtils
+from app.utils.system import SystemUtils
 
 
 class TmdbScraper:
     tmdb = None
+    _transfer_type = settings.TRANSFER_TYPE
 
     def __init__(self, tmdb):
         self.tmdb = tmdb
 
-    def gen_scraper_files(self, mediainfo: MediaInfo, file_path: Path):
+    def gen_scraper_files(self, mediainfo: MediaInfo, file_path: Path, transfer_type: str):
         """
         生成刮削文件，包括NFO和图片，传入路径为文件路径
         :param mediainfo: 媒体信息
         :param file_path: 文件路径或者目录路径
+        :param transfer_type: 传输类型
         """
 
+        self._transfer_type = transfer_type
+
         def __get_episode_detail(_seasoninfo: dict, _episode: int):
             """
             根据季信息获取集的信息
@@ -328,9 +334,8 @@ class TmdbScraper:
         # 保存文件
         self.__save_nfo(doc, file_path.with_suffix(".nfo"))
 
-    @staticmethod
     @retry(RequestException, logger=logger)
-    def __save_image(url: str, file_path: Path):
+    def __save_image(self, url: str, file_path: Path):
         """
         下载图片并保存
         """
@@ -340,7 +345,10 @@ class TmdbScraper:
             logger.info(f"正在下载{file_path.stem}图片：{url} ...")
             r = RequestUtils().get_res(url=url, raise_exception=True)
             if r:
-                file_path.write_bytes(r.content)
+                if self._transfer_type in ['rclone_move', 'rclone_copy']:
+                    self.__save_remove_file(file_path, r.content)
+                else:
+                    file_path.write_bytes(r.content)
                 logger.info(f"图片已保存：{file_path}")
             else:
                 logger.info(f"{file_path.stem}图片下载失败，请检查网络连通性")
@@ -349,13 +357,29 @@ class TmdbScraper:
         except Exception as err:
             logger.error(f"{file_path.stem}图片下载失败：{err}")
 
-    @staticmethod
-    def __save_nfo(doc, file_path: Path):
+    def __save_nfo(self, doc, file_path: Path):
         """
         保存NFO
         """
         if file_path.exists():
             return
         xml_str = doc.toprettyxml(indent="  ", encoding="utf-8")
-        file_path.write_bytes(xml_str)
+        if self._transfer_type in ['rclone_move', 'rclone_copy']:
+            self.__save_remove_file(file_path, xml_str)
+        else:
+            file_path.write_bytes(xml_str)
         logger.info(f"NFO文件已保存：{file_path}")
+
+    def __save_remove_file(self, out_file: Path, content: Union[str, bytes]):
+        """
+        保存文件到远端
+        """
+        temp_file = settings.TEMP_PATH / str(out_file)[1:]
+        temp_file_dir = temp_file.parent
+        if not temp_file_dir.exists():
+            temp_file_dir.mkdir(parents=True, exist_ok=True)
+        temp_file.write_bytes(content)
+        if self._transfer_type == 'rclone_move':
+            SystemUtils.rclone_move(temp_file, out_file)
+        elif self._transfer_type == 'rclone_copy':
+            SystemUtils.rclone_copy(temp_file, out_file)

app/plugins/autosignin/__init__.py

@@ -92,7 +92,7 @@ class AutoSignIn(_PluginBase):
             self._clean = config.get("clean")
 
             # 过滤掉已删除的站点
-            all_sites = [site for site in self.sites.get_indexers() if not site.get("public")]
+            all_sites = [site for site in self.sites.get_indexers() if not site.get("public")] + self.__custom_sites()
             self._sign_sites = [site.get("id") for site in all_sites if site.get("id") in self._sign_sites]
             self._login_sites = [site.get("id") for site in all_sites if site.get("id") in self._login_sites]
             # 保存配置
@@ -244,9 +244,13 @@ class AutoSignIn(_PluginBase):
         """
         拼装插件配置页面，需要返回两块数据：1、页面配置；2、数据结构
         """
-        # 站点的可选项
-        site_options = [{"title": site.name, "value": site.id}
-                        for site in Site.list_order_by_pri(self.db)]
+        # 站点的可选项（内置站点 + 自定义站点）
+        customSites = self.__custom_sites()
+
+        site_options = ([{"title": site.name, "value": site.id}
+                         for site in Site.list_order_by_pri(self.db)]
+                        + [{"title": site.get("name"), "value": site.get("id")}
+                           for site in customSites])
         return [
             {
                 'component': 'VForm',
@@ -452,6 +456,13 @@ class AutoSignIn(_PluginBase):
             "retry_keyword": "错误|失败"
         }
 
+    def __custom_sites(self) -> List[dict]:
+        custom_sites = []
+        custom_sites_config = self.get_config("CustomSites")
+        if custom_sites_config and custom_sites_config.get("enabled"):
+            custom_sites = custom_sites_config.get("sites")
+        return custom_sites
+
     def get_page(self) -> List[dict]:
         """
         拼装插件详情页面，需要返回页面配置，同时附带数据
@@ -590,7 +601,7 @@ class AutoSignIn(_PluginBase):
         today_history = self.get_data(key=type + "-" + today)
 
         # 查询所有站点
-        all_sites = [site for site in self.sites.get_indexers() if not site.get("public")]
+        all_sites = [site for site in self.sites.get_indexers() if not site.get("public")] + self.__custom_sites()
         # 过滤掉没有选中的站点
         if do_sites:
             do_sites = [site for site in all_sites if site.get("id") in do_sites]

app/plugins/brushflow/__init__.py

@@ -747,7 +747,7 @@ class BrushFlow(_PluginBase):
 
     def get_page(self) -> List[dict]:
         # 种子明细
-        data_list = self.get_data("torrents") or {}
+        torrents = self.get_data("torrents") or {}
         # 统计数据
         stattistic_data: Dict[str, dict] = self.get_data("statistic") or {
             "count": 0,
@@ -755,7 +755,7 @@ class BrushFlow(_PluginBase):
             "uploaded": 0,
             "downloaded": 0,
         }
-        if not data_list:
+        if not torrents:
             return [
                 {
                     'component': 'div',
@@ -766,7 +766,9 @@ class BrushFlow(_PluginBase):
                 }
             ]
         else:
-            data_list = data_list.values()
+            data_list = torrents.values()
+            # 按time倒序排序
+            data_list = sorted(data_list, key=lambda x: x.get("time") or 0, reverse=True)
         # 总上传量格式化
         total_upload = StringUtils.str_filesize(stattistic_data.get("uploaded") or 0)
         # 总下载量格式化
@@ -1379,6 +1381,7 @@ class BrushFlow(_PluginBase):
                         "downloaded": 0,
                         "uploaded": 0,
                         "deleted": False,
+                        "time": time.time()
                     }
                     # 统计数据
                     torrents_size += torrent.size

app/plugins/customsites/__init__.py

@@ -0,0 +1,250 @@
+from typing import Any, List, Dict, Tuple
+from urllib.parse import urlparse
+
+from app.core.config import settings
+from app.core.event import EventManager
+from app.helper.cookiecloud import CookieCloudHelper
+from app.log import logger
+from app.plugins import _PluginBase
+from app.schemas.types import EventType
+
+
+class CustomSites(_PluginBase):
+    # 插件名称
+    plugin_name = "自定义站点"
+    # 插件描述
+    plugin_desc = "增加自定义站点为签到和统计使用。"
+    # 插件图标
+    plugin_icon = "world.png"
+    # 主题色
+    plugin_color = "#9AC16C"
+    # 插件版本
+    plugin_version = "0.1"
+    # 插件作者
+    plugin_author = "lightolly"
+    # 作者主页
+    author_url = "https://github.com/lightolly"
+    # 插件配置项ID前缀
+    plugin_config_prefix = "customsites_"
+    # 加载顺序
+    plugin_order = 0
+    # 可使用的用户级别
+    auth_level = 2
+
+    # 自定义站点起始 id
+    site_id_base = 60000
+    site_id_alloc = site_id_base
+
+    # 私有属性
+    cookie_cloud: CookieCloudHelper = None
+
+    # 配置属性
+    _enabled: bool = False
+    """
+    {
+    "id": "站点ID",
+    "name": "站点名称",
+    "url": "站点地址",
+    "cookie": "站点Cookie",
+    "ua": "User-Agent",
+    "proxy": "是否使用代理",
+    "render": "是否仿真",
+    }
+    """
+    _sites: list[Dict] = []
+    """
+    格式
+    站点名称|url|是否仿真
+    """
+    _site_urls: str = ""
+
+    def init_plugin(self, config: dict = None):
+        self.cookie_cloud = CookieCloudHelper(
+            server=settings.COOKIECLOUD_HOST,
+            key=settings.COOKIECLOUD_KEY,
+            password=settings.COOKIECLOUD_PASSWORD
+        )
+
+        del_sites = []
+        sites = []
+        new_site_urls = []
+        # 配置
+        if config:
+            self._enabled = config.get("enabled", False)
+            self._sites = config.get("sites", [])
+            self._site_urls = config.get("site_urls", "")
+
+            if not self._enabled:
+                return
+
+            site_urls = self._site_urls.splitlines()
+            # 只保留 匹配site_urls的 sites
+            urls = [site_url.split('|')[1] for site_url in site_urls]
+            for site in self._sites:
+                if site.get("url") not in urls:
+                    del_sites.append(site)
+                else:
+                    sites.append(site)
+
+            for item in site_urls:
+                _, url, _ = item.split("|")
+                if url in [site.get("url") for site in self._sites]:
+                    continue
+                else:
+                    new_site_urls.append(item)
+
+            # 获取待分配的最大ID
+            alloc_ids = [site.get("id") for site in self._sites if site.get("id")] + [self.site_id_base]
+            self.site_id_alloc = max(alloc_ids) + 1
+
+            # 补全 site_id
+            for item in new_site_urls:
+                site_name, item, site_render = item.split("|")
+                sites.append({
+                    "id": self.site_id_alloc,
+                    "name": site_name,
+                    "url": item,
+                    "render": True if site_render.upper() == 'Y' else False,
+                    "cookie": "",
+                })
+                self.site_id_alloc += 1
+            self._sites = sites
+            # 保存配置
+            self.sync_cookie()
+            self.__update_config()
+
+        # 通知站点删除
+        for site in del_sites:
+            self.delete_site(site.get("id"))
+            logger.info(f"删除站点 {site.get('name')}")
+
+    def get_state(self) -> bool:
+        return self._enabled
+
+    def __update_config(self):
+        # 保存配置
+        self.update_config(
+            {
+                "enabled": self._enabled,
+                "sites": self._sites,
+                "site_urls": self._site_urls
+            }
+        )
+
+    def __get_site_by_domain(self, domain):
+        for site in self._sites:
+            site_domain = urlparse(site.get("url")).netloc
+            if site_domain.endswith(domain):
+                return site
+        return None
+
+    def sync_cookie(self):
+        """
+        通过CookieCloud同步站点Cookie
+        """
+        logger.info("开始同步CookieCloud站点 ...")
+        cookies, msg = self.cookie_cloud.download()
+        if not cookies:
+            logger.error(f"CookieCloud同步失败：{msg}")
+            return
+        # 保存Cookie或新增站点
+        _update_count = 0
+        for domain, cookie in cookies.items():
+            # 获取站点信息
+            site_info = self.__get_site_by_domain(domain)
+            if site_info:
+                # 更新站点Cookie
+                logger.info(f"更新站点 {domain} Cookie ...")
+                site_info.update({"cookie": cookie})
+                _update_count += 1
+
+        # 处理完成
+        ret_msg = f"更新了{_update_count}个站点，总{len(self._sites)}个站点"
+        logger.info(f"自定义站点 Cookie同步成功：{ret_msg}")
+
+    @staticmethod
+    def get_command() -> List[Dict[str, Any]]:
+        pass
+
+    def get_api(self) -> List[Dict[str, Any]]:
+        pass
+
+    def get_form(self) -> Tuple[List[dict], Dict[str, Any]]:
+        """
+        拼装插件配置页面，需要返回两块数据：1、页面配置；2、数据结构
+        """
+        return [
+            {
+                'component': 'VForm',
+                'content': [
+                    {
+                        'component': 'VRow',
+                        'content': [
+                            {
+                                'component': 'VCol',
+                                'props': {
+                                    'cols': 12,
+                                    'md': 6
+                                },
+                                'content': [
+                                    {
+                                        'component': 'VSwitch',
+                                        'props': {
+                                            'model': 'enabled',
+                                            'label': '启用插件',
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    },
+                    {
+                        'component': 'VRow',
+                        'content': [
+                            {
+                                'component': 'VCol',
+                                'props': {
+                                    'cols': 12
+                                },
+                                'content': [
+                                    {
+                                        'component': 'VTextarea',
+                                        'props': {
+                                            'model': 'site_urls',
+                                            'label': '站点列表',
+                                            'rows': 5,
+                                            'placeholder': '每一行一个站点，配置方式：\n'
+                                                           '站点名称|站点地址|是否仿真(Y/N)\n'
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                ]
+            }
+        ], {
+            "enabled": False,
+            "site_urls": [],
+            "sites": self._sites
+        }
+
+    def get_page(self) -> List[dict]:
+        pass
+
+    def stop_service(self):
+        """
+        退出插件
+        """
+        pass
+
+    @staticmethod
+    def delete_site(site_id):
+        """
+        删除站点通知
+        """
+        # 插件站点删除
+        EventManager().send_event(EventType.SiteDeleted,
+                                  {
+                                      "site_id": site_id
+                                  })

app/plugins/dirmonitor/__init__.py

@@ -1,12 +1,12 @@
+import datetime
 import re
 import shutil
 import threading
 import traceback
-from datetime import datetime
 from pathlib import Path
-from threading import Event
 from typing import List, Tuple, Dict, Any
 
+import pytz
 from apscheduler.schedulers.background import BackgroundScheduler
 from watchdog.events import FileSystemEventHandler
 from watchdog.observers import Observer
@@ -16,6 +16,7 @@ from app.chain.tmdb import TmdbChain
 from app.chain.transfer import TransferChain
 from app.core.config import settings
 from app.core.context import MediaInfo
+from app.core.event import eventmanager, Event
 from app.core.metainfo import MetaInfoPath
 from app.db.downloadhistory_oper import DownloadHistoryOper
 from app.db.transferhistory_oper import TransferHistoryOper
@@ -79,6 +80,7 @@ class DirMonitor(_PluginBase):
     _observer = []
     _enabled = False
     _notify = False
+    _onlyonce = False
     # 模式 compatibility/fast
     _mode = "fast"
     # 转移方式
@@ -91,7 +93,7 @@ class DirMonitor(_PluginBase):
     _transferconf: Dict[str, str] = {}
     _medias = {}
     # 退出事件
-    _event = Event()
+    _event = threading.Event()
 
     def init_plugin(self, config: dict = None):
         self.transferhis = TransferHistoryOper(self.db)
@@ -106,6 +108,7 @@ class DirMonitor(_PluginBase):
         if config:
             self._enabled = config.get("enabled")
             self._notify = config.get("notify")
+            self._onlyonce = config.get("onlyonce")
             self._mode = config.get("mode")
             self._transfer_type = config.get("transfer_type")
             self._monitor_dirs = config.get("monitor_dirs") or ""
@@ -114,10 +117,13 @@ class DirMonitor(_PluginBase):
         # 停止现有任务
         self.stop_service()
 
-        if self._enabled:
+        if self._enabled or self._onlyonce:
+            # 定时服务管理器
             self._scheduler = BackgroundScheduler(timezone=settings.TZ)
+            # 追加入库消息统一发送服务
+            self._scheduler.add_job(self.send_msg, trigger='interval', seconds=30)
 
-            # 启动任务
+            # 读取目录配置
             monitor_dirs = self._monitor_dirs.split("\n")
             if not monitor_dirs:
                 return
@@ -152,47 +158,100 @@ class DirMonitor(_PluginBase):
                 # 转移方式
                 self._transferconf[mon_path] = _transfer_type
 
-                # 检查媒体库目录是不是下载目录的子目录
-                try:
-                    if target_path and target_path.is_relative_to(Path(mon_path)):
-                        logger.warn(f"{target_path} 是下载目录 {mon_path} 的子目录，无法监控")
-                        self.systemmessage.put(f"{target_path} 是下载目录 {mon_path} 的子目录，无法监控")
-                        continue
-                except Exception as e:
-                    logger.debug(str(e))
-                    pass
+                # 启用目录监控
+                if self._enabled:
+                    # 检查媒体库目录是不是下载目录的子目录
+                    try:
+                        if target_path and target_path.is_relative_to(Path(mon_path)):
+                            logger.warn(f"{target_path} 是下载目录 {mon_path} 的子目录，无法监控")
+                            self.systemmessage.put(f"{target_path} 是下载目录 {mon_path} 的子目录，无法监控")
+                            continue
+                    except Exception as e:
+                        logger.debug(str(e))
+                        pass
 
-                try:
-                    if self._mode == "compatibility":
-                        # 兼容模式，目录同步性能降低且NAS不能休眠，但可以兼容挂载的远程共享目录如SMB
-                        observer = PollingObserver(timeout=10)
-                    else:
-                        # 内部处理系统操作类型选择最优解
-                        observer = Observer(timeout=10)
-                    self._observer.append(observer)
-                    observer.schedule(FileMonitorHandler(mon_path, self), path=mon_path, recursive=True)
-                    observer.daemon = True
-                    observer.start()
-                    logger.info(f"{mon_path} 的目录监控服务启动")
-                except Exception as e:
-                    err_msg = str(e)
-                    if "inotify" in err_msg and "reached" in err_msg:
-                        logger.warn(
-                            f"目录监控服务启动出现异常：{err_msg}，请在宿主机上（不是docker容器内）执行以下命令并重启："
-                            + """
-                                 echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf
-                                 echo fs.inotify.max_user_instances=524288 | sudo tee -a /etc/sysctl.conf
-                                 sudo sysctl -p
-                                 """)
-                    else:
-                        logger.error(f"{mon_path} 启动目录监控失败：{err_msg}")
-                    self.systemmessage.put(f"{mon_path} 启动目录监控失败：{err_msg}")
+                    try:
+                        if self._mode == "compatibility":
+                            # 兼容模式，目录同步性能降低且NAS不能休眠，但可以兼容挂载的远程共享目录如SMB
+                            observer = PollingObserver(timeout=10)
+                        else:
+                            # 内部处理系统操作类型选择最优解
+                            observer = Observer(timeout=10)
+                        self._observer.append(observer)
+                        observer.schedule(FileMonitorHandler(mon_path, self), path=mon_path, recursive=True)
+                        observer.daemon = True
+                        observer.start()
+                        logger.info(f"{mon_path} 的目录监控服务启动")
+                    except Exception as e:
+                        err_msg = str(e)
+                        if "inotify" in err_msg and "reached" in err_msg:
+                            logger.warn(
+                                f"目录监控服务启动出现异常：{err_msg}，请在宿主机上（不是docker容器内）执行以下命令并重启："
+                                + """
+                                     echo fs.inotify.max_user_watches=524288 | sudo tee -a /etc/sysctl.conf
+                                     echo fs.inotify.max_user_instances=524288 | sudo tee -a /etc/sysctl.conf
+                                     sudo sysctl -p
+                                     """)
+                        else:
+                            logger.error(f"{mon_path} 启动目录监控失败：{err_msg}")
+                        self.systemmessage.put(f"{mon_path} 启动目录监控失败：{err_msg}")
 
-            # 追加入库消息统一发送服务
-            self._scheduler.add_job(self.send_msg, trigger='interval', seconds=15)
-            # 启动服务
-            self._scheduler.print_jobs()
-            self._scheduler.start()
+            # 运行一次定时服务
+            if self._onlyonce:
+                logger.info("目录监控服务启动，立即运行一次")
+                self._scheduler.add_job(func=self.sync_all, trigger='date',
+                                        run_date=datetime.datetime.now(
+                                            tz=pytz.timezone(settings.TZ)) + datetime.timedelta(seconds=3)
+                                        )
+                # 关闭一次性开关
+                self._onlyonce = False
+                # 保存配置
+                self.__update_config()
+
+            # 启动定时服务
+            if self._scheduler.get_jobs():
+                self._scheduler.print_jobs()
+                self._scheduler.start()
+
+    def __update_config(self):
+        """
+        更新配置
+        """
+        self.update_config({
+            "enabled": self._enabled,
+            "notify": self._notify,
+            "onlyonce": self._onlyonce,
+            "mode": self._mode,
+            "transfer_type": self._transfer_type,
+            "monitor_dirs": self._monitor_dirs,
+            "exclude_keywords": self._exclude_keywords
+        })
+
+    @eventmanager.register(EventType.DirectorySync)
+    def remote_sync(self, event: Event):
+        """
+        远程全量同步
+        """
+        if event:
+            self.post_message(channel=event.event_data.get("channel"),
+                              title="开始同步监控目录 ...",
+                              userid=event.event_data.get("user"))
+        self.sync_all()
+        if event:
+            self.post_message(channel=event.event_data.get("channel"),
+                              title="监控目录同步完成！", userid=event.event_data.get("user"))
+
+    def sync_all(self):
+        """
+        立即运行一次，全量同步目录中所有文件
+        """
+        logger.info("开始全量同步监控目录 ...")
+        # 遍历所有监控目录
+        for mon_path in self._dirconf.keys():
+            # 遍历目录下所有文件
+            for file_path in SystemUtils.list_files(Path(mon_path), settings.RMT_MEDIAEXT):
+                self.__handle_file(event_path=str(file_path), mon_path=mon_path)
+        logger.info("全量同步监控目录完成！")
 
     def event_handler(self, event, mon_path: str, text: str, event_path: str):
         """
@@ -204,137 +263,136 @@ class DirMonitor(_PluginBase):
         """
         if not event.is_directory:
             # 文件发生变化
-            file_path = Path(event_path)
-            try:
-                if not file_path.exists():
+            logger.debug("文件%s：%s" % (text, event_path))
+            self.__handle_file(event_path=event_path, mon_path=mon_path)
+
+    def __handle_file(self, event_path: str, mon_path: str):
+        """
+        同步一个文件
+        :param event_path: 事件文件路径
+        :param mon_path: 监控目录
+        """
+        file_path = Path(event_path)
+        try:
+            if not file_path.exists():
+                return
+            # 全程加锁
+            with lock:
+                transfer_history = self.transferhis.get_by_src(event_path)
+                if transfer_history:
+                    logger.debug("文件已处理过：%s" % event_path)
                     return
 
-                logger.debug("文件%s：%s" % (text, event_path))
+                # 回收站及隐藏的文件不处理
+                if event_path.find('/@Recycle/') != -1 \
+                        or event_path.find('/#recycle/') != -1 \
+                        or event_path.find('/.') != -1 \
+                        or event_path.find('/@eaDir') != -1:
+                    logger.debug(f"{event_path} 是回收站或隐藏的文件")
+                    return
 
-                # 全程加锁
-                with lock:
-                    transfer_history = self.transferhis.get_by_src(event_path)
-                    if transfer_history:
-                        logger.debug("文件已处理过：%s" % event_path)
-                        return
+                # 命中过滤关键字不处理
+                if self._exclude_keywords:
+                    for keyword in self._exclude_keywords.split("\n"):
+                        if keyword and re.findall(keyword, event_path):
+                            logger.info(f"{event_path} 命中过滤关键字 {keyword}，不处理")
+                            return
 
-                    # 回收站及隐藏的文件不处理
-                    if event_path.find('/@Recycle/') != -1 \
-                            or event_path.find('/#recycle/') != -1 \
-                            or event_path.find('/.') != -1 \
-                            or event_path.find('/@eaDir') != -1:
-                        logger.debug(f"{event_path} 是回收站或隐藏的文件")
-                        return
+                # 整理屏蔽词不处理
+                transfer_exclude_words = self.systemconfig.get(SystemConfigKey.TransferExcludeWords)
+                if transfer_exclude_words:
+                    for keyword in transfer_exclude_words:
+                        if not keyword:
+                            continue
+                        if keyword and re.search(r"%s" % keyword, event_path, re.IGNORECASE):
+                            logger.info(f"{event_path} 命中整理屏蔽词 {keyword}，不处理")
+                            return
 
-                    # 命中过滤关键字不处理
-                    if self._exclude_keywords:
-                        for keyword in self._exclude_keywords.split("\n"):
-                            if keyword and re.findall(keyword, event_path):
-                                logger.info(f"{event_path} 命中过滤关键字 {keyword}，不处理")
-                                return
+                # 不是媒体文件不处理
+                if file_path.suffix not in settings.RMT_MEDIAEXT:
+                    logger.debug(f"{event_path} 不是媒体文件")
+                    return
 
-                    # 整理屏蔽词不处理
-                    transfer_exclude_words = self.systemconfig.get(SystemConfigKey.TransferExcludeWords)
-                    if transfer_exclude_words:
-                        for keyword in transfer_exclude_words:
-                            if not keyword:
-                                continue
-                            if keyword and re.search(r"%s" % keyword, event_path, re.IGNORECASE):
-                                logger.info(f"{event_path} 命中整理屏蔽词 {keyword}，不处理")
-                                return
+                # 元数据
+                file_meta = MetaInfoPath(file_path)
+                if not file_meta.name:
+                    logger.error(f"{file_path.name} 无法识别有效信息")
+                    return
 
-                    # 不是媒体文件不处理
-                    if file_path.suffix not in settings.RMT_MEDIAEXT:
-                        logger.debug(f"{event_path} 不是媒体文件")
-                        return
+                # 判断是不是蓝光目录
+                if re.search(r"BDMV[/\\]STREAM", event_path, re.IGNORECASE):
+                    # 截取BDMV前面的路径
+                    event_path = event_path[:event_path.find("BDMV")]
+                    file_path = Path(event_path)
 
-                    # 查询历史记录，已转移的不处理
-                    if self.transferhis.get_by_src(event_path):
-                        logger.info(f"{event_path} 已整理过")
-                        return
+                # 查询历史记录，已转移的不处理
+                if self.transferhis.get_by_src(event_path):
+                    logger.info(f"{event_path} 已整理过")
+                    return
 
-                    # 元数据
-                    file_meta = MetaInfoPath(file_path)
-                    if not file_meta.name:
-                        logger.error(f"{file_path.name} 无法识别有效信息")
-                        return
-
-                    # 查询转移目的目录
-                    target: Path = self._dirconf.get(mon_path)
-                    # 查询转移方式
-                    transfer_type = self._transferconf.get(mon_path)
-
-                    # 识别媒体信息
-                    mediainfo: MediaInfo = self.chain.recognize_media(meta=file_meta)
-                    if not mediainfo:
-                        logger.warn(f'未识别到媒体信息，标题：{file_meta.name}')
-                        if self._notify:
-                            self.chain.post_message(Notification(
-                                mtype=NotificationType.Manual,
-                                title=f"{file_path.name} 未识别到媒体信息，无法入库！"
-                            ))
-                        # 新增转移成功历史记录
-                        self.transferhis.add_fail(
-                            src_path=file_path,
-                            mode=transfer_type,
-                            meta=file_meta
-                        )
-                        return
-
-                    # 如果未开启新增已入库媒体是否跟随TMDB信息变化则根据tmdbid查询之前的title
-                    if not settings.SCRAP_FOLLOW_TMDB:
-                        transfer_history = self.transferhis.get_by_type_tmdbid(tmdbid=mediainfo.tmdb_id,
-                                                                               mtype=mediainfo.type.value)
-                        if transfer_history:
-                            mediainfo.title = transfer_history.title
-                    logger.info(f"{file_path.name} 识别为：{mediainfo.type.value} {mediainfo.title_year}")
-
-                    # 更新媒体图片
-                    self.chain.obtain_images(mediainfo=mediainfo)
-
-                    # 获取集数据
-                    if mediainfo.type == MediaType.TV:
-                        episodes_info = self.tmdbchain.tmdb_episodes(tmdbid=mediainfo.tmdb_id,
-                                                                     season=file_meta.begin_season or 1)
-                    else:
-                        episodes_info = None
-
-                    # 获取downloadhash
-                    download_hash = self.get_download_hash(src=str(file_path))
-
-                    # 转移
-                    transferinfo: TransferInfo = self.chain.transfer(mediainfo=mediainfo,
-                                                                     path=file_path,
-                                                                     transfer_type=transfer_type,
-                                                                     target=target,
-                                                                     meta=file_meta,
-                                                                     episodes_info=episodes_info)
-
-                    if not transferinfo:
-                        logger.error("文件转移模块运行失败")
-                        return
-                    if not transferinfo.success:
-                        # 转移失败
-                        logger.warn(f"{file_path.name} 入库失败：{transferinfo.message}")
-                        # 新增转移失败历史记录
-                        self.transferhis.add_fail(
-                            src_path=file_path,
-                            mode=transfer_type,
-                            download_hash=download_hash,
-                            meta=file_meta,
-                            mediainfo=mediainfo,
-                            transferinfo=transferinfo
-                        )
-                        if self._notify:
-                            self.chain.post_message(Notification(
-                                title=f"{mediainfo.title_year}{file_meta.season_episode} 入库失败！",
-                                text=f"原因：{transferinfo.message or '未知'}",
-                                image=mediainfo.get_message_image()
-                            ))
-                        return
+                # 查询转移目的目录
+                target: Path = self._dirconf.get(mon_path)
+                # 查询转移方式
+                transfer_type = self._transferconf.get(mon_path)
+                # 根据父路径获取下载历史
+                download_history = self.downloadhis.get_by_path(Path(event_path).parent)
 
+                # 识别媒体信息
+                mediainfo: MediaInfo = self.chain.recognize_media(meta=file_meta,
+                                                                  tmdbid=download_history.tmdbid if download_history else None)
+                if not mediainfo:
+                    logger.warn(f'未识别到媒体信息，标题：{file_meta.name}')
                     # 新增转移成功历史记录
-                    self.transferhis.add_success(
+                    his = self.transferhis.add_fail(
+                        src_path=file_path,
+                        mode=transfer_type,
+                        meta=file_meta
+                    )
+                    if self._notify:
+                        self.chain.post_message(Notification(
+                            mtype=NotificationType.Manual,
+                            title=f"{file_path.name} 未识别到媒体信息，无法入库！\n"
+                                  f"回复：```\n/redo {his.id} [tmdbid]|[类型]\n``` 手动识别转移。"
+                        ))
+                    return
+
+                # 如果未开启新增已入库媒体是否跟随TMDB信息变化则根据tmdbid查询之前的title
+                if not settings.SCRAP_FOLLOW_TMDB:
+                    transfer_history = self.transferhis.get_by_type_tmdbid(tmdbid=mediainfo.tmdb_id,
+                                                                           mtype=mediainfo.type.value)
+                    if transfer_history:
+                        mediainfo.title = transfer_history.title
+                logger.info(f"{file_path.name} 识别为：{mediainfo.type.value} {mediainfo.title_year}")
+
+                # 更新媒体图片
+                self.chain.obtain_images(mediainfo=mediainfo)
+
+                # 获取集数据
+                if mediainfo.type == MediaType.TV:
+                    episodes_info = self.tmdbchain.tmdb_episodes(tmdbid=mediainfo.tmdb_id,
+                                                                 season=file_meta.begin_season or 1)
+                else:
+                    episodes_info = None
+
+                # 获取downloadhash
+                download_hash = self.get_download_hash(src=str(file_path))
+
+                # 转移
+                transferinfo: TransferInfo = self.chain.transfer(mediainfo=mediainfo,
+                                                                 path=file_path,
+                                                                 transfer_type=transfer_type,
+                                                                 target=target,
+                                                                 meta=file_meta,
+                                                                 episodes_info=episodes_info)
+
+                if not transferinfo:
+                    logger.error("文件转移模块运行失败")
+                    return
+                if not transferinfo.success:
+                    # 转移失败
+                    logger.warn(f"{file_path.name} 入库失败：{transferinfo.message}")
+                    # 新增转移失败历史记录
+                    self.transferhis.add_fail(
                         src_path=file_path,
                         mode=transfer_type,
                         download_hash=download_hash,
@@ -342,94 +400,112 @@ class DirMonitor(_PluginBase):
                         mediainfo=mediainfo,
                         transferinfo=transferinfo
                     )
+                    if self._notify:
+                        self.chain.post_message(Notification(
+                            title=f"{mediainfo.title_year}{file_meta.season_episode} 入库失败！",
+                            text=f"原因：{transferinfo.message or '未知'}",
+                            image=mediainfo.get_message_image()
+                        ))
+                    return
 
-                    # 刮削单个文件
-                    if settings.SCRAP_METADATA:
-                        self.chain.scrape_metadata(path=transferinfo.target_path,
-                                                   mediainfo=mediainfo)
+                # 新增转移成功历史记录
+                self.transferhis.add_success(
+                    src_path=file_path,
+                    mode=transfer_type,
+                    download_hash=download_hash,
+                    meta=file_meta,
+                    mediainfo=mediainfo,
+                    transferinfo=transferinfo
+                )
 
-                    """
-                    {
-                        "title_year season": {
-                            "files": [
-                                {
-                                    "path":,
-                                    "mediainfo":,
-                                    "file_meta":,
-                                    "transferinfo":
-                                }
-                            ],
-                            "time": "2023-08-24 23:23:23.332"
-                        }
+                # 刮削单个文件
+                if settings.SCRAP_METADATA:
+                    self.chain.scrape_metadata(path=transferinfo.target_path,
+                                               mediainfo=mediainfo,
+                                               transfer_type=transfer_type)
+
+                """
+                {
+                    "title_year season": {
+                        "files": [
+                            {
+                                "path":,
+                                "mediainfo":,
+                                "file_meta":,
+                                "transferinfo":
+                            }
+                        ],
+                        "time": "2023-08-24 23:23:23.332"
                     }
-                    """
-                    # 发送消息汇总
-                    media_list = self._medias.get(mediainfo.title_year + " " + file_meta.season) or {}
-                    if media_list:
-                        media_files = media_list.get("files") or []
-                        if media_files:
-                            file_exists = False
-                            for file in media_files:
-                                if str(event_path) == file.get("path"):
-                                    file_exists = True
-                                    break
-                            if not file_exists:
-                                media_files.append({
-                                    "path": event_path,
-                                    "mediainfo": mediainfo,
-                                    "file_meta": file_meta,
-                                    "transferinfo": transferinfo
-                                })
-                            else:
-                                media_files = [
-                                    {
-                                        "path": event_path,
-                                        "mediainfo": mediainfo,
-                                        "file_meta": file_meta,
-                                        "transferinfo": transferinfo
-                                    }
-                                ]
-                        media_list = {
-                            "files": media_files,
-                            "time": datetime.now()
-                        }
-                    else:
-                        media_list = {
-                            "files": [
+                }
+                """
+                # 发送消息汇总
+                media_list = self._medias.get(mediainfo.title_year + " " + file_meta.season) or {}
+                if media_list:
+                    media_files = media_list.get("files") or []
+                    if media_files:
+                        file_exists = False
+                        for file in media_files:
+                            if str(event_path) == file.get("path"):
+                                file_exists = True
+                                break
+                        if not file_exists:
+                            media_files.append({
+                                "path": event_path,
+                                "mediainfo": mediainfo,
+                                "file_meta": file_meta,
+                                "transferinfo": transferinfo
+                            })
+                        else:
+                            media_files = [
                                 {
                                     "path": event_path,
                                     "mediainfo": mediainfo,
                                     "file_meta": file_meta,
                                     "transferinfo": transferinfo
                                 }
-                            ],
-                            "time": datetime.now()
-                        }
-                    self._medias[mediainfo.title_year + " " + file_meta.season] = media_list
+                            ]
+                    media_list = {
+                        "files": media_files,
+                        "time": datetime.datetime.now()
+                    }
+                else:
+                    media_list = {
+                        "files": [
+                            {
+                                "path": event_path,
+                                "mediainfo": mediainfo,
+                                "file_meta": file_meta,
+                                "transferinfo": transferinfo
+                            }
+                        ],
+                        "time": datetime.datetime.now()
+                    }
+                self._medias[mediainfo.title_year + " " + file_meta.season] = media_list
 
-                    # 汇总刷新媒体库
-                    if settings.REFRESH_MEDIASERVER:
-                        self.chain.refresh_mediaserver(mediainfo=mediainfo, file_path=transferinfo.target_path)
-                    # 广播事件
-                    self.eventmanager.send_event(EventType.TransferComplete, {
-                        'meta': file_meta,
-                        'mediainfo': mediainfo,
-                        'transferinfo': transferinfo
-                    })
+                # 汇总刷新媒体库
+                if settings.REFRESH_MEDIASERVER:
+                    self.chain.refresh_mediaserver(mediainfo=mediainfo, file_path=transferinfo.target_path)
+                # 广播事件
+                self.eventmanager.send_event(EventType.TransferComplete, {
+                    'meta': file_meta,
+                    'mediainfo': mediainfo,
+                    'transferinfo': transferinfo
+                })
 
-                    # 移动模式删除空目录
-                    if transfer_type == "move":
-                        for file_dir in file_path.parents:
-                            if len(str(file_dir)) <= len(str(Path(mon_path))):
-                                # 重要，删除到监控目录为止
-                                break
-                            files = SystemUtils.list_files(file_dir, settings.RMT_MEDIAEXT)
-                            if not files:
-                                logger.warn(f"移动模式，删除空目录：{file_dir}")
-                                shutil.rmtree(file_dir, ignore_errors=True)
+                # 移动模式删除空目录
+                if transfer_type == "move":
+                    for file_dir in file_path.parents:
+                        if len(str(file_dir)) <= len(str(Path(mon_path))):
+                            # 重要，删除到监控目录为止
+                            break
+                        files = SystemUtils.list_files(file_dir, settings.RMT_MEDIAEXT)
+                        if not files:
+                            logger.warn(f"移动模式，删除空目录：{file_dir}")
+                            shutil.rmtree(file_dir, ignore_errors=True)
 
-            except Exception as e:
-                logger.error("目录监控发生错误：%s - %s" % (str(e), traceback.format_exc()))
+        except Exception as e:
+            logger.error("目录监控发生错误：%s - %s" % (str(e), traceback.format_exc()))
 
     def send_msg(self):
         """
@@ -456,7 +532,7 @@ class DirMonitor(_PluginBase):
             file_meta = media_files[0].get("file_meta")
             mediainfo = media_files[0].get("mediainfo")
             # 判断最后更新时间距现在是已超过5秒，超过则发送消息
-            if (datetime.now() - last_update_time).total_seconds() > 5:
+            if (datetime.datetime.now() - last_update_time).total_seconds() > 5:
                 # 发送通知
                 if self._notify:
 
@@ -508,7 +584,17 @@ class DirMonitor(_PluginBase):
 
     @staticmethod
     def get_command() -> List[Dict[str, Any]]:
-        pass
+        """
+        定义远程控制命令
+        :return: 命令关键字、事件、描述、附带数据
+        """
+        return [{
+            "cmd": "/directory_sync",
+            "event": EventType.DirectorySync,
+            "desc": "目录监控同步",
+            "category": "管理",
+            "data": {}
+        }]
 
     def get_api(self) -> List[Dict[str, Any]]:
         pass
@@ -525,7 +611,7 @@ class DirMonitor(_PluginBase):
                                 'component': 'VCol',
                                 'props': {
                                     'cols': 12,
-                                    'md': 6
+                                    'md': 4
                                 },
                                 'content': [
                                     {
@@ -541,7 +627,7 @@ class DirMonitor(_PluginBase):
                                 'component': 'VCol',
                                 'props': {
                                     'cols': 12,
-                                    'md': 6
+                                    'md': 4
                                 },
                                 'content': [
                                     {
@@ -552,6 +638,22 @@ class DirMonitor(_PluginBase):
                                         }
                                     }
                                 ]
+                            },
+                            {
+                                'component': 'VCol',
+                                'props': {
+                                    'cols': 12,
+                                    'md': 4
+                                },
+                                'content': [
+                                    {
+                                        'component': 'VSwitch',
+                                        'props': {
+                                            'model': 'onlyonce',
+                                            'label': '立即运行一次',
+                                        }
+                                    }
+                                ]
                             }
                         ]
                     },
@@ -617,11 +719,11 @@ class DirMonitor(_PluginBase):
                                             'model': 'monitor_dirs',
                                             'label': '监控目录',
                                             'rows': 5,
-                                            'placeholder': '每一行一个目录，支持三种配置方式：\n'
+                                            'placeholder': '每一行一个目录，支持以下几种配置方式，转移方式支持 move、copy、link、softlink、rclone_copy、rclone_move：\n'
                                                            '监控目录\n'
-                                                           '监控目录#转移方式（move|copy|link|softlink|rclone_copy|rclone_move）\n'
-                                                           '监控目录:转移目的目录（需同时在媒体库目录中配置该目的目录）\n'
-                                                           '监控目录:转移目的目录#转移方式（move|copy|link|softlink|rclone_copy|rclone_move）'
+                                                           '监控目录#转移方式\n'
+                                                           '监控目录:转移目的目录\n'
+                                                           '监控目录:转移目的目录#转移方式'
                                         }
                                     }
                                 ]
@@ -655,6 +757,7 @@ class DirMonitor(_PluginBase):
         ], {
             "enabled": False,
             "notify": False,
+            "onlyonce": False,
             "mode": "fast",
             "transfer_type": settings.TRANSFER_TYPE,
             "monitor_dirs": "",

app/plugins/downloadingmsg/__init__.py

@@ -117,7 +117,7 @@ class DownloadingMsg(_PluginBase):
                 if not userid:
                     continue
                 # 如果用户是管理员，无需重复推送
-                if self._type == "admin" or self._type == "both" and self._adminuser and userid in str(
+                if (self._type == "admin" or self._type == "both") and self._adminuser and userid in str(
                         self._adminuser).split(","):
                     logger.debug("管理员已推送")
                     continue
@@ -177,10 +177,14 @@ class DownloadingMsg(_PluginBase):
             else:
                 media_name = torrent.title
 
-            messages.append(f"{index}. {media_name}\n"
-                            f"{torrent.title} "
-                            f"{StringUtils.str_filesize(torrent.size)} "
-                            f"{round(torrent.progress, 1)}%")
+            if not self._adminuser or userid not in str(self._adminuser).split(","):
+                # 下载用户发送精简消息
+                messages.append(f"{index}. {media_name} {round(torrent.progress, 1)}%")
+            else:
+                messages.append(f"{index}. {media_name}\n"
+                                f"{torrent.title} "
+                                f"{StringUtils.str_filesize(torrent.size)} "
+                                f"{round(torrent.progress, 1)}%")
             index += 1
 
         # 用户消息渠道

app/plugins/libraryscraper/__init__.py

@@ -390,7 +390,7 @@ class LibraryScraper(_PluginBase):
 
             # 刮削单个文件
             if scrap_metadata:
-                self.chain.scrape_metadata(path=file, mediainfo=mediainfo)
+                self.chain.scrape_metadata(path=file, mediainfo=mediainfo, transfer_type=settings.TRANSFER_TYPE)
 
     @staticmethod
     def __get_tmdbid_from_nfo(file_path: Path):

app/plugins/mediasyncdel/__init__.py

@@ -1013,40 +1013,42 @@ class MediaSyncDel(_PluginBase):
                 if not isinstance(torrents, list):
                     torrents = [torrents]
 
-                # 删除辅种历史中与本下载器相同的辅种记录
-                if str(downloader) == str(download):
-                    for torrent in torrents:
-                        handle_cnt += 1
-                        if str(download) == "qbittorrent":
-                            # 删除辅种
-                            if action_flag == "del":
-                                logger.info(f"删除辅种：{downloader} - {torrent}")
-                                self.qb.delete_torrents(delete_file=True,
-                                                        ids=torrent)
-                            # 暂停辅种
-                            if action_flag == "stop":
-                                self.qb.stop_torrents(torrent)
-                                logger.info(f"辅种：{downloader} - {torrent} 暂停")
-                        else:
-                            # 删除辅种
-                            if action_flag == "del":
-                                logger.info(f"删除辅种：{downloader} - {torrent}")
-                                self.tr.delete_torrents(delete_file=True,
-                                                        ids=torrent)
-                            # 暂停辅种
-                            if action_flag == "stop":
-                                self.tr.stop_torrents(torrent)
-                                logger.info(f"辅种：{downloader} - {torrent} 暂停")
-                    # 删除本下载器辅种历史
-                    if action_flag == "del":
-                        del history
-                    break
+                # 删除辅种历史
+                for torrent in torrents:
+                    handle_cnt += 1
+                    if str(download) == "qbittorrent":
+                        # 删除辅种
+                        if action_flag == "del":
+                            logger.info(f"删除辅种：{downloader} - {torrent}")
+                            self.qb.delete_torrents(delete_file=True,
+                                                    ids=torrent)
+                        # 暂停辅种
+                        if action_flag == "stop":
+                            self.qb.stop_torrents(torrent)
+                            logger.info(f"辅种：{downloader} - {torrent} 暂停")
+                    else:
+                        # 删除辅种
+                        if action_flag == "del":
+                            logger.info(f"删除辅种：{downloader} - {torrent}")
+                            self.tr.delete_torrents(delete_file=True,
+                                                    ids=torrent)
+                        # 暂停辅种
+                        if action_flag == "stop":
+                            self.tr.stop_torrents(torrent)
+                            logger.info(f"辅种：{downloader} - {torrent} 暂停")
+                # 删除本下载器辅种历史
+                if action_flag == "del":
+                    del history
+                break
 
             # 更新辅种历史
-            self.save_data(key=history_key,
-                           value=seed_history,
-                           plugin_id=plugin_id)
-
+            if seed_history:
+                self.save_data(key=history_key,
+                               value=seed_history,
+                               plugin_id=plugin_id)
+            else:
+                self.del_data(key=history_key,
+                              plugin_id=plugin_id)
         return handle_cnt
 
     @staticmethod
@@ -1276,8 +1278,6 @@ class MediaSyncDel(_PluginBase):
         """
         下载文件删除处理事件
         """
-        if not self._enabled:
-            return
         if not event:
             return
         event_data = event.event_data

app/plugins/nastoolsync/__init__.py

@@ -139,43 +139,61 @@ class NAStoolSync(_PluginBase):
             plugin_key = history[2]
             plugin_value = history[3]
 
-            # 处理下载器映射
-            if self._downloader:
-                downloaders = self._downloader.split("\n")
-                for downloader in downloaders:
-                    if not downloader:
-                        continue
-                    sub_downloaders = downloader.split(":")
-                    if not str(sub_downloaders[0]).isdigit():
-                        logger.error(f"下载器映射配置错误：NAStool下载器id 应为数字！")
-                        continue
-                    # 替换转种记录
-                    if str(plugin_id) == "TorrentTransfer":
-                        keys = str(plugin_key).split("-")
-                        if keys[0].isdigit() and int(keys[0]) == int(sub_downloaders[0]):
-                            # 替换key
-                            plugin_key = plugin_key.replace(keys[0], sub_downloaders[1])
+            # 替换转种记录
+            if str(plugin_id) == "TorrentTransfer":
+                keys = str(plugin_key).split("-")
 
-                        # 替换value
-                        if isinstance(plugin_value, str):
-                            _value: dict = json.loads(plugin_value)
-                        elif isinstance(plugin_value, dict):
-                            if str(plugin_value.get("to_download")).isdigit() and int(
-                                    plugin_value.get("to_download")) == int(sub_downloaders[0]):
-                                plugin_value["to_download"] = sub_downloaders[1]
+                # 1-2cd5d6fe32dca4e39a3e9f10961bfbdb00437e91
+                if len(keys) == 2 and keys[0].isdigit():
+                    mp_downloader = self.__get_target_downloader(int(keys[0]))
+                    # 替换key
+                    plugin_key = mp_downloader + "-" + keys[1]
 
-                    # 替换辅种记录
-                    if str(plugin_id) == "IYUUAutoSeed":
-                        if isinstance(plugin_value, str):
-                            plugin_value: list = json.loads(plugin_value)
-                        if not isinstance(plugin_value, list):
-                            plugin_value = [plugin_value]
-                        for value in plugin_value:
-                            if not str(value.get("downloader")).isdigit():
-                                continue
-                            if str(value.get("downloader")).isdigit() and int(value.get("downloader")) == int(
-                                    sub_downloaders[0]):
-                                value["downloader"] = sub_downloaders[1]
+                    # 替换value
+                    """
+                    {
+                        "to_download":2,
+                        "to_download_id":"2cd5d6fe32dca4e39a3e9f10961bfbdb00437e91",
+                        "delete_source":true
+                    }
+                    """
+                    if isinstance(plugin_value, str):
+                        plugin_value: dict = json.loads(plugin_value)
+                    if isinstance(plugin_value, dict):
+                        if str(plugin_value.get("to_download")).isdigit():
+                            to_downloader = self.__get_target_downloader(int(plugin_value.get("to_download")))
+                            plugin_value["to_download"] = to_downloader
+
+            # 替换辅种记录
+            elif str(plugin_id) == "IYUUAutoSeed":
+                """
+                [
+                    {
+                        "downloader":"2",
+                        "torrents":[
+                            "a18aa62abab42613edba15e7dbad0d729d8500da",
+                            "e494f372316bbfd8572da80138a6ef4c491d5991",
+                            "cc2bbc1e654d8fc0f83297f6cd36a38805aa2864",
+                            "68aec0db3aa7fe28a887e5e41a0d0d5bc284910f",
+                            "f02962474287e11441e34e40b8326ddf28d034f6"
+                        ]
+                    },
+                    {
+                        "downloader":"2",
+                        "torrents":[
+                            "4f042003ce90519e1aadd02b76f51c0c0711adb3"
+                        ]
+                    }
+                ]
+                """
+                if isinstance(plugin_value, str):
+                    plugin_value: list = json.loads(plugin_value)
+                if not isinstance(plugin_value, list):
+                    plugin_value = [plugin_value]
+                for value in plugin_value:
+                    if str(value.get("downloader")).isdigit():
+                        downloader = self.__get_target_downloader(int(value.get("downloader")))
+                        value["downloader"] = downloader
 
             self._plugindata.save(plugin_id=plugin_id,
                                   key=plugin_key,
@@ -189,6 +207,24 @@ class NAStoolSync(_PluginBase):
 
         logger.info(f"插件记录已同步完成。总耗时 {(end_time - start_time).seconds} 秒")
 
+    def __get_target_downloader(self, download_id: int):
+        """
+        获取NAStool下载器id对应的Moviepilot下载器
+        """
+        # 处理下载器映射
+        if self._downloader:
+            downloaders = self._downloader.split("\n")
+            for downloader in downloaders:
+                if not downloader:
+                    continue
+                sub_downloaders = downloader.split(":")
+                if not str(sub_downloaders[0]).isdigit():
+                    logger.error(f"下载器映射配置错误：NAStool下载器id 应为数字！")
+                    continue
+                if int(sub_downloaders[0]) == download_id:
+                    return str(sub_downloaders[1])
+        return download_id
+
     def sync_download_history(self, download_history):
         """
         导入下载记录

app/plugins/personmeta/__init__.py

@@ -64,6 +64,7 @@ class PersonMeta(_PluginBase):
     _onlyonce = False
     _cron = None
     _delay = 0
+    _type = "all"
     _remove_nozh = False
 
     def init_plugin(self, config: dict = None):
@@ -73,6 +74,7 @@ class PersonMeta(_PluginBase):
             self._enabled = config.get("enabled")
             self._onlyonce = config.get("onlyonce")
             self._cron = config.get("cron")
+            self._type = config.get("type") or "all"
             self._delay = config.get("delay") or 0
             self._remove_nozh = config.get("remove_nozh") or False
 
@@ -116,6 +118,7 @@ class PersonMeta(_PluginBase):
             "enabled": self._enabled,
             "onlyonce": self._onlyonce,
             "cron": self._cron,
+            "type": self._type,
             "delay": self._delay,
             "remove_nozh": self._remove_nozh
         })
@@ -182,7 +185,7 @@ class PersonMeta(_PluginBase):
                                 'component': 'VCol',
                                 'props': {
                                     'cols': 12,
-                                    'md': 6
+                                    'md': 4
                                 },
                                 'content': [
                                     {
@@ -199,7 +202,7 @@ class PersonMeta(_PluginBase):
                                 'component': 'VCol',
                                 'props': {
                                     'cols': 12,
-                                    'md': 6
+                                    'md': 4
                                 },
                                 'content': [
                                     {
@@ -211,6 +214,27 @@ class PersonMeta(_PluginBase):
                                         }
                                     }
                                 ]
+                            },
+                            {
+                                'component': 'VCol',
+                                'props': {
+                                    'cols': 12,
+                                    'md': 4
+                                },
+                                'content': [
+                                    {
+                                        'component': 'VSelect',
+                                        'props': {
+                                            'model': 'type',
+                                            'label': '刮削条件',
+                                            'items': [
+                                                {'title': '全部', 'value': 'all'},
+                                                {'title': '演员非中文', 'value': 'name'},
+                                                {'title': '角色非中文', 'value': 'role'},
+                                            ]
+                                        }
+                                    }
+                                ]
                             }
                         ]
                     },
@@ -241,6 +265,7 @@ class PersonMeta(_PluginBase):
             "enabled": False,
             "onlyonce": False,
             "cron": "",
+            "type": "all",
             "delay": 30,
             "remove_nozh": False
         }
@@ -350,10 +375,21 @@ class PersonMeta(_PluginBase):
         """
 
         def __need_trans_actor(_item):
-            # 是否需要处理人物信息
-            _peoples = [x for x in _item.get("People", []) if
-                        (x.get("Name") and not StringUtils.is_chinese(x.get("Name")))
-                        or (x.get("Role") and not StringUtils.is_chinese(x.get("Role")))]
+            """
+            是否需要处理人物信息
+            """
+            if self._type == "name":
+                # 是否需要处理人物名称
+                _peoples = [x for x in _item.get("People", []) if
+                            (x.get("Name") and not StringUtils.is_chinese(x.get("Name")))]
+            elif self._type == "role":
+                # 是否需要处理人物角色
+                _peoples = [x for x in _item.get("People", []) if
+                            (x.get("Role") and not StringUtils.is_chinese(x.get("Role")))]
+            else:
+                _peoples = [x for x in _item.get("People", []) if
+                            (x.get("Name") and not StringUtils.is_chinese(x.get("Name")))
+                            or (x.get("Role") and not StringUtils.is_chinese(x.get("Role")))]
             if _peoples:
                 return True
             return False
@@ -456,7 +492,7 @@ class PersonMeta(_PluginBase):
             # 查询媒体库人物详情
             personinfo = self.get_iteminfo(server=server, itemid=people.get("Id"))
             if not personinfo:
-                logger.warn(f"未找到人物 {people.get('Name')} 的信息")
+                logger.debug(f"未找到人物 {people.get('Name')} 的信息")
                 return None
 
             # 是否更新标志
@@ -473,20 +509,20 @@ class PersonMeta(_PluginBase):
                     cn_name = self.__get_chinese_name(person_tmdbinfo)
                     if cn_name:
                         # 更新中文名
-                        logger.info(f"{people.get('Name')} 从TMDB获取到中文名：{cn_name}")
+                        logger.debug(f"{people.get('Name')} 从TMDB获取到中文名：{cn_name}")
                         personinfo["Name"] = cn_name
                         ret_people["Name"] = cn_name
                         updated_name = True
                         # 更新中文描述
                         biography = person_tmdbinfo.get("biography")
                         if biography and StringUtils.is_chinese(biography):
-                            logger.info(f"{people.get('Name')} 从TMDB获取到中文描述")
+                            logger.debug(f"{people.get('Name')} 从TMDB获取到中文描述")
                             personinfo["Overview"] = biography
                             updated_overview = True
                         # 图片
                         profile_path = person_tmdbinfo.get('profile_path')
                         if profile_path:
-                            logger.info(f"{people.get('Name')} 从TMDB获取到图片：{profile_path}")
+                            logger.debug(f"{people.get('Name')} 从TMDB获取到图片：{profile_path}")
                             profile_path = f"https://{settings.TMDB_IMAGE_DOMAIN}/t/p/original{profile_path}"
 
             # 从豆瓣信息中更新人物信息
@@ -522,14 +558,14 @@ class PersonMeta(_PluginBase):
                             or douban_actor.get("name") == people.get("Name"):
                         # 名称
                         if not updated_name:
-                            logger.info(f"{people.get('Name')} 从豆瓣中获取到中文名：{douban_actor.get('name')}")
+                            logger.debug(f"{people.get('Name')} 从豆瓣中获取到中文名：{douban_actor.get('name')}")
                             personinfo["Name"] = douban_actor.get("name")
                             ret_people["Name"] = douban_actor.get("name")
                             updated_name = True
                         # 描述
                         if not updated_overview:
                             if douban_actor.get("title"):
-                                logger.info(f"{people.get('Name')} 从豆瓣中获取到中文描述：{douban_actor.get('title')}")
+                                logger.debug(f"{people.get('Name')} 从豆瓣中获取到中文描述：{douban_actor.get('title')}")
                                 personinfo["Overview"] = douban_actor.get("title")
                                 updated_overview = True
                         # 饰演角色
@@ -541,20 +577,20 @@ class PersonMeta(_PluginBase):
                                 character = re.sub("演员", "",
                                                    character)
                                 if character:
-                                    logger.info(f"{people.get('Name')} 从豆瓣中获取到饰演角色：{character}")
+                                    logger.debug(f"{people.get('Name')} 从豆瓣中获取到饰演角色：{character}")
                                     ret_people["Role"] = character
                                     update_character = True
                         # 图片
                         if not profile_path:
                             avatar = douban_actor.get("avatar") or {}
                             if avatar.get("large"):
-                                logger.info(f"{people.get('Name')} 从豆瓣中获取到图片：{avatar.get('large')}")
+                                logger.debug(f"{people.get('Name')} 从豆瓣中获取到图片：{avatar.get('large')}")
                                 profile_path = avatar.get("large")
                         break
 
             # 更新人物图片
             if profile_path:
-                logger.info(f"更新人物 {people.get('Name')} 的图片：{profile_path}")
+                logger.debug(f"更新人物 {people.get('Name')} 的图片：{profile_path}")
                 self.set_item_image(server=server, itemid=people.get("Id"), imageurl=profile_path)
 
             # 锁定人物信息
@@ -567,12 +603,12 @@ class PersonMeta(_PluginBase):
 
             # 更新人物信息
             if updated_name or updated_overview or update_character:
-                logger.info(f"更新人物 {people.get('Name')} 的信息：{personinfo}")
+                logger.debug(f"更新人物 {people.get('Name')} 的信息：{personinfo}")
                 ret = self.set_iteminfo(server=server, itemid=people.get("Id"), iteminfo=personinfo)
                 if ret:
                     return ret_people
             else:
-                logger.info(f"人物 {people.get('Name')} 未找到中文数据")
+                logger.debug(f"人物 {people.get('Name')} 未找到中文数据")
         except Exception as err:
             logger.error(f"更新人物信息失败：{err}")
         return None
@@ -583,7 +619,7 @@ class PersonMeta(_PluginBase):
         """
         # 随机休眠 3-10 秒
         sleep_time = 3 + int(time.time()) % 7
-        logger.info(f"随机休眠 {sleep_time}秒 ...")
+        logger.debug(f"随机休眠 {sleep_time}秒 ...")
         time.sleep(sleep_time)
         # 匹配豆瓣信息
         doubaninfo = self.chain.match_doubaninfo(name=mediainfo.title,
@@ -596,7 +632,7 @@ class PersonMeta(_PluginBase):
             doubanitem = self.chain.douban_info(doubaninfo.get("id")) or {}
             return (doubanitem.get("actors") or []) + (doubanitem.get("directors") or [])
         else:
-            logger.warn(f"未找到豆瓣信息：{mediainfo.title_year}")
+            logger.debug(f"未找到豆瓣信息：{mediainfo.title_year}")
         return []
 
     @staticmethod
@@ -882,7 +918,7 @@ class PersonMeta(_PluginBase):
                 if r:
                     return base64.b64encode(r.content).decode()
                 else:
-                    logger.info(f"{imageurl} 图片下载失败，请检查网络连通性")
+                    logger.warn(f"{imageurl} 图片下载失败，请检查网络连通性")
             except Exception as err:
                 logger.error(f"下载图片失败：{err}")
             return None

app/plugins/sitestatistic/__init__.py

@@ -86,7 +86,8 @@ class SiteStatistic(_PluginBase):
             self._statistic_sites = config.get("statistic_sites") or []
 
             # 过滤掉已删除的站点
-            self._statistic_sites = [site.get("id") for site in self.sites.get_indexers() if
+            all_sites = [site for site in self.sites.get_indexers() if not site.get("public")] + self.__custom_sites()
+            self._statistic_sites = [site.get("id") for site in all_sites if
                                      not site.get("public") and site.get("id") in self._statistic_sites]
             self.__update_config()
 
@@ -182,9 +183,14 @@ class SiteStatistic(_PluginBase):
         """
         拼装插件配置页面，需要返回两块数据：1、页面配置；2、数据结构
         """
-        # 站点的可选项
-        site_options = [{"title": site.name, "value": site.id}
+        # 站点的可选项（内置站点 + 自定义站点）
+        customSites = self.__custom_sites()
+
+        site_options = ([{"title": site.name, "value": site.id}
                         for site in Site.list_order_by_pri(self.db)]
+                        + [{"title": site.get("name"), "value": site.get("id")}
+                           for site in customSites])
+
         return [
             {
                 'component': 'VForm',
@@ -1048,11 +1054,12 @@ class SiteStatistic(_PluginBase):
 
         with lock:
 
+            all_sites = [site for site in self.sites.get_indexers() if not site.get("public")] + self.__custom_sites()
             # 没有指定站点，默认使用全部站点
             if not self._statistic_sites:
-                refresh_sites = [site for site in self.sites.get_indexers() if not site.get("public")]
+                refresh_sites = all_sites
             else:
-                refresh_sites = [site for site in self.sites.get_indexers() if
+                refresh_sites = [site for site in all_sites if
                                  site.get("id") in self._statistic_sites]
             if not refresh_sites:
                 return
@@ -1115,6 +1122,13 @@ class SiteStatistic(_PluginBase):
             self.save_data("last_update_time", key)
             logger.info("站点数据刷新完成")
 
+    def __custom_sites(self) -> List[dict]:
+        custom_sites = []
+        custom_sites_config = self.get_config("CustomSites")
+        if custom_sites_config and custom_sites_config.get("enabled"):
+            custom_sites = custom_sites_config.get("sites")
+        return custom_sites
+
     def __update_config(self):
         self.update_config({
             "enabled": self._enabled,

app/schemas/transfer.py

@@ -12,6 +12,7 @@ class TransferTorrent(BaseModel):
     path: Optional[Path] = None
     hash: Optional[str] = None
     tags: Optional[str] = None
+    userid: Optional[str] = None
 
 
 class DownloadingTorrent(BaseModel):
@@ -29,6 +30,7 @@ class DownloadingTorrent(BaseModel):
     upspeed: Optional[str] = None
     dlspeed: Optional[str] = None
     media: Optional[dict] = {}
+    userid: Optional[str] = None
 
 
 class TransferInfo(BaseModel):

app/schemas/types.py

@@ -44,6 +44,8 @@ class EventType(Enum):
     NameRecognize = "name.recognize"
     # 名称识别结果
     NameRecognizeResult = "name.recognize.result"
+    # 目录监控同步
+    DirectorySync = "directory.sync"
 
 
 # 系统配置Key字典
@@ -72,8 +74,10 @@ class SystemConfigKey(Enum):
     SubscribeFilterRules = "SubscribeFilterRules"
     # 洗版规则
     BestVersionFilterRules = "BestVersionFilterRules"
-    # 默认过滤规则
+    # 默认订阅过滤规则
     DefaultFilterRules = "DefaultFilterRules"
+    # 默认搜索过滤规则
+    DefaultSearchFilterRules = "DefaultSearchFilterRules"
     # 转移屏蔽词
     TransferExcludeWords = "TransferExcludeWords"
 

app/utils/system.py

@@ -99,6 +99,8 @@ class SystemUtils:
         try:
             # link到当前目录并改名
             tmp_path = src.parent / (dest.name + ".mp")
+            if tmp_path.exists():
+                tmp_path.unlink()
             tmp_path.hardlink_to(src)
             # 移动到目标目录
             shutil.move(tmp_path, dest)

version.py

@@ -1 +1 @@
-APP_VERSION = 'v1.3.2'
+APP_VERSION = 'v1.3.4'