fix #655

fix: container id retrieval error

.github/workflows/build.yml

@@ -26,7 +26,7 @@ jobs:
       - 
         name: Docker meta
         id: meta
-        uses: docker/metadata-action@v4
+        uses: docker/metadata-action@v5
         with:
           images: ${{ secrets.DOCKER_USERNAME }}/moviepilot
           tags: |
@@ -35,22 +35,22 @@ jobs:
 
       -
         name: Set Up QEMU
-        uses: docker/setup-qemu-action@v2
+        uses: docker/setup-qemu-action@v3
 
       -
         name: Set Up Buildx
-        uses: docker/setup-buildx-action@v2
+        uses: docker/setup-buildx-action@v3
 
       -
         name: Login DockerHub
-        uses: docker/login-action@v2
+        uses: docker/login-action@v3
         with:
           username: ${{ secrets.DOCKER_USERNAME }}
           password: ${{ secrets.DOCKER_PASSWORD }}
 
       -
         name: Build Image
-        uses: docker/build-push-action@v4
+        uses: docker/build-push-action@v5
         with:
           context: .
           file: Dockerfile

README.md

@@ -81,10 +81,10 @@ docker pull jxxghp/moviepilot:latest
 - **OCR_HOST：** OCR识别服务器地址，格式：`http(s)://ip:port`，用于识别站点二维码实现自动登录获取Cookie等，不配置默认使用内建服务器`https://movie-pilot.org`，可使用 [这个镜像](https://hub.docker.com/r/jxxghp/moviepilot-ocr) 自行搭建。
 - **USER_AGENT：** CookieCloud对应的浏览器UA，可选，设置后可增加连接站点的成功率，同步站点后可以在管理界面中修改
 - **AUTO_DOWNLOAD_USER：** 交互搜索自动下载用户ID，使用,分割
-- **SUBSCRIBE_MODE：** 订阅模式，`rss`/`spider`，默认`spider`，`rss`模式通过定时刷新RSS来匹配订阅（RSS地址会自动获取，也可手动维护），对站点压力小，同时可设置订阅刷新周期，24小时运行，推荐使用该模式。
+- **SUBSCRIBE_MODE：** 订阅模式，`rss`/`spider`，默认`spider`，`rss`模式通过定时刷新RSS来匹配订阅（RSS地址会自动获取，也可手动维护），对站点压力小，同时可设置订阅刷新周期，24小时运行，但订阅和下载通知不能过滤和显示免费，推荐使用rss模式。
 - **SUBSCRIBE_RSS_INTERVAL：** RSS订阅模式刷新时间间隔（分钟），默认`30`分钟，不能小于5分钟。
 - **SUBSCRIBE_SEARCH：** 订阅搜索，`true`/`false`，默认`false`，开启后会每隔24小时对所有订阅进行全量搜索，以补齐缺失剧集（一般情况下正常订阅即可，订阅搜索只做为兜底，会增加站点压力，不建议开启）。
-- **MESSAGER：** 消息通知渠道，支持 `telegram`/`wechat`/`slack`，开启多个渠道时使用`,`分隔。同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`telegram`
+- **MESSAGER：** 消息通知渠道，支持 `telegram`/`wechat`/`slack`/`synologychat`，开启多个渠道时使用`,`分隔。同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`telegram`
 
   - `wechat`设置项：
 
@@ -108,6 +108,11 @@ docker pull jxxghp/moviepilot:latest
     - **SLACK_OAUTH_TOKEN：** Slack Bot User OAuth Token
     - **SLACK_APP_TOKEN：** Slack App-Level Token
     - **SLACK_CHANNEL：** Slack 频道名称，默认`全体`
+  
+  - `synologychat`设置项：
+
+    - **SYNOLOGYCHAT_WEBHOOK：** 在Synology Chat中创建机器人，获取机器人`传入URL`
+    - **SYNOLOGYCHAT_TOKEN：** SynologyChat机器人`令牌`
 
 
 - **DOWNLOADER：** 下载器，支持`qbittorrent`/`transmission`，QB版本号要求>= 4.3.9，TR版本号要求>= 3.0，同时还需要配置对应渠道的环境变量，非对应渠道的变量可删除，推荐使用`qbittorrent`
@@ -127,7 +132,7 @@ docker pull jxxghp/moviepilot:latest
 
 - **DOWNLOADER_MONITOR：** 下载器监控，`true`/`false`，默认为`true`，开启后下载完成时才会自动整理入库
 
-- **MEDIASERVER：** 媒体服务器，支持`emby`/`jellyfin`/`plex`，同时还需要配置对应媒体服务器的环境变量，非对应媒体服务器的变量可删除，推荐使用`emby`
+- **MEDIASERVER：** 媒体服务器，支持`emby`/`jellyfin`/`plex`，同时开启多个使用`,`分隔。还需要配置对应媒体服务器的环境变量，非对应媒体服务器的变量可删除，推荐使用`emby`
 
   - `emby`设置项：
 
@@ -145,27 +150,29 @@ docker pull jxxghp/moviepilot:latest
     - **PLEX_TOKEN：** Plex网页Url中的`X-Plex-Token`，通过浏览器F12->网络从请求URL中获取
 
 - **MEDIASERVER_SYNC_INTERVAL:** 媒体服务器同步间隔（小时），默认`6`，留空则不同步
+- **MEDIASERVER_SYNC_BLACKLIST:** 媒体服务器同步黑名单，多个媒体库名称使用,分割
 
 
 ### 2. **用户认证**
 
-- **AUTH_SITE：** 认证站点，支持`hhclub`/`audiences`/`hddolby`/`zmpt`/`freefarm`/`hdfans`/`wintersakura`/`leaves`/`1ptba`/`icc2022`/`iyuu`
+- **AUTH_SITE：** 认证站点，支持`iyuu`/`hhclub`/`audiences`/`hddolby`/`zmpt`/`freefarm`/`hdfans`/`wintersakura`/`leaves`/`1ptba`/`icc2022`/`ptlsp`
 
 `MoviePilot`需要认证后才能使用，配置`AUTH_SITE`后，需要根据下表配置对应站点的认证参数。
 
-| 站点 | 参数                                                    |
-|:--:|:-----------------------------------------------------:|
-| iyuu | `IYUU_SIGN`：IYUU登录令牌                                  |
-| hhclub | `HHCLUB_USERNAME`：用户名<br/>`HHCLUB_PASSKEY`：密钥         |
-| audiences | `AUDIENCES_UID`：用户ID<br/>`AUDIENCES_PASSKEY`：密钥       |
-| hddolby | `HDDOLBY_ID`：用户ID<br/>`HDDOLBY_PASSKEY`：密钥            |
-| zmpt | `ZMPT_UID`：用户ID<br/>`ZMPT_PASSKEY`：密钥                 |
-| freefarm | `FREEFARM_UID`：用户ID<br/>`FREEFARM_PASSKEY`：密钥         |
-| hdfans | `HDFANS_UID`：用户ID<br/>`HDFANS_PASSKEY`：密钥             |
+|      站点      |                          参数                           |
+|:------------:|:-----------------------------------------------------:|
+|     iyuu     |                 `IYUU_SIGN`：IYUU登录令牌                  |
+|    hhclub    |     `HHCLUB_USERNAME`：用户名<br/>`HHCLUB_PASSKEY`：密钥     |
+|  audiences   |    `AUDIENCES_UID`：用户ID<br/>`AUDIENCES_PASSKEY`：密钥    |
+|   hddolby    |      `HDDOLBY_ID`：用户ID<br/>`HDDOLBY_PASSKEY`：密钥       |
+|     zmpt     |         `ZMPT_UID`：用户ID<br/>`ZMPT_PASSKEY`：密钥         |
+|   freefarm   |     `FREEFARM_UID`：用户ID<br/>`FREEFARM_PASSKEY`：密钥     |
+|    hdfans    |       `HDFANS_UID`：用户ID<br/>`HDFANS_PASSKEY`：密钥       |
 | wintersakura | `WINTERSAKURA_UID`：用户ID<br/>`WINTERSAKURA_PASSKEY`：密钥 |
-| leaves | `LEAVES_UID`：用户ID<br/>`LEAVES_PASSKEY`：密钥             |
-| 1ptba | `1PTBA_UID`：用户ID<br/>`1PTBA_PASSKEY`：密钥               |
-| icc2022 | `ICC2022_UID`：用户ID<br/>`ICC2022_PASSKEY`：密钥           |
+|    leaves    |       `LEAVES_UID`：用户ID<br/>`LEAVES_PASSKEY`：密钥       |
+|    1ptba     |        `1PTBA_UID`：用户ID<br/>`1PTBA_PASSKEY`：密钥        |
+|   icc2022    |      `ICC2022_UID`：用户ID<br/>`ICC2022_PASSKEY`：密钥      |
+|    ptlsp     |        `PTLSP_UID`：用户ID<br/>`PTLSP_PASSKEY`：密钥        |
 
 
 ### 2. **进阶配置**
@@ -227,9 +234,9 @@ docker pull jxxghp/moviepilot:latest
 - 通过CookieCloud同步快速同步站点，不需要使用的站点可在WEB管理界面中禁用，无法同步的站点可手动新增。
 - 通过WEB进行管理，将WEB添加到手机桌面获得类App使用效果，管理界面端口：`3000`，后台API端口：`3001`。
 - 通过下载器监控或使用目录监控插件实现自动整理入库刮削（二选一）。
-- 通过微信/Telegram/Slack远程管理，其中微信/Telegram将会自动添加操作菜单（微信菜单条数有限制，部分菜单不显示），微信需要在官方页面设置回调地址，地址相对路径为：`/api/v1/message/`。
+- 通过微信/Telegram/Slack/SynologyChat远程管理，其中微信/Telegram将会自动添加操作菜单（微信菜单条数有限制，部分菜单不显示）；微信需要在官方页面设置回调地址，SynologyChat需要设置机器人传入地址，地址相对路径为：`/api/v1/message/`。
 - 设置媒体服务器Webhook，通过MoviePilot发送播放通知等。Webhook回调相对路径为`/api/v1/webhook?token=moviepilot`（`3001`端口），其中`moviepilot`为设置的`API_TOKEN`。
-- 将MoviePilot做为Radarr或Sonarr服务器添加到Overseerr或Jellyseerr（`3001`端口），可使用Overseerr/Jellyseerr浏览订阅。
+- 将MoviePilot做为Radarr或Sonarr服务器添加到Overseerr或Jellyseerr（`API服务端口`），可使用Overseerr/Jellyseerr浏览订阅。
 - 映射宿主机docker.sock文件到容器`/var/run/docker.sock`，以支持内建重启操作。实例：`-v /var/run/docker.sock:/var/run/docker.sock:ro`
 
 **注意**

alembic/versions/1e169250e949_1_0_4.py

@@ -27,4 +27,4 @@ def upgrade() -> None:
 
 
 def downgrade() -> None:
-    pass
+    pass

alembic/versions/232dfa044617_1_0_6.py

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

alembic/versions/30329639c12b_1_0_7.py

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

app/api/endpoints/dashboard.py

@@ -1,5 +1,5 @@
 from pathlib import Path
-from typing import Any, List
+from typing import Any, List, Optional
 
 from fastapi import APIRouter, Depends
 from requests import Session
@@ -11,9 +11,7 @@ from app.core.security import verify_token
 from app.db import get_db
 from app.db.models.transferhistory import TransferHistory
 from app.scheduler import Scheduler
-from app.utils.string import StringUtils
 from app.utils.system import SystemUtils
-from app.utils.timer import TimerUtils
 
 router = APIRouter()
 
@@ -24,14 +22,16 @@ def statistic(db: Session = Depends(get_db),
     """
     查询媒体数量统计信息
     """
-    media_statistic = DashboardChain(db).media_statistic()
-    if media_statistic:
-        return schemas.Statistic(
-            movie_count=media_statistic.movie_count,
-            tv_count=media_statistic.tv_count,
-            episode_count=media_statistic.episode_count,
-            user_count=media_statistic.user_count
-        )
+    media_statistics: Optional[List[schemas.Statistic]] = DashboardChain(db).media_statistic()
+    if media_statistics:
+        # 汇总各媒体库统计信息
+        ret_statistic = schemas.Statistic()
+        for media_statistic in media_statistics:
+            ret_statistic.movie_count += media_statistic.movie_count
+            ret_statistic.tv_count += media_statistic.tv_count
+            ret_statistic.episode_count += media_statistic.episode_count
+            ret_statistic.user_count += media_statistic.user_count
+        return ret_statistic
     else:
         return schemas.Statistic()
 
@@ -64,13 +64,16 @@ def downloader(db: Session = Depends(get_db),
     """
     transfer_info = DashboardChain(db).downloader_info()
     free_space = SystemUtils.free_space(Path(settings.DOWNLOAD_PATH))
-    return schemas.DownloaderInfo(
-        download_speed=transfer_info.download_speed,
-        upload_speed=transfer_info.upload_speed,
-        download_size=transfer_info.download_size,
-        upload_size=transfer_info.upload_size,
-        free_space=free_space
-    )
+    if transfer_info:
+        return schemas.DownloaderInfo(
+            download_speed=transfer_info.download_speed,
+            upload_speed=transfer_info.upload_speed,
+            download_size=transfer_info.download_size,
+            upload_size=transfer_info.upload_size,
+            free_space=free_space
+        )
+    else:
+        return schemas.DownloaderInfo()
 
 
 @router.get("/schedule", summary="后台服务", response_model=List[schemas.ScheduleInfo])
@@ -78,37 +81,7 @@ def schedule(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     查询后台服务信息
     """
-    # 返回计时任务
-    schedulers = []
-    # 去重
-    added = []
-    jobs = Scheduler().list()
-    # 按照下次运行时间排序
-    jobs.sort(key=lambda x: x.next_run_time)
-    for job in jobs:
-        if job.name not in added:
-            added.append(job.name)
-        else:
-            continue
-        if not StringUtils.is_chinese(job.name):
-            continue
-        if not job.next_run_time:
-            status = "已停止"
-            next_run = ""
-        else:
-            next_run = TimerUtils.time_difference(job.next_run_time)
-            if not next_run:
-                status = "正在运行"
-            else:
-                status = "阻塞" if job.pending else "等待"
-        schedulers.append(schemas.ScheduleInfo(
-            id=job.id,
-            name=job.name,
-            status=status,
-            next_run=next_run
-        ))
-
-    return schedulers
+    return Scheduler().list()
 
 
 @router.get("/transfer", summary="文件整理统计", response_model=List[int])

app/api/endpoints/history.py

@@ -62,20 +62,22 @@ def transfer_history(title: str = None,
 
 @router.delete("/transfer", summary="删除转移历史记录", response_model=schemas.Response)
 def delete_transfer_history(history_in: schemas.TransferHistory,
-                            delete_file: bool = False,
+                            deletesrc: bool = False,
+                            deletedest: bool = False,
                             db: Session = Depends(get_db),
                             _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     删除转移历史记录
     """
-    # 触发删除事件
-    if delete_file:
-        history = TransferHistory.get(db, history_in.id)
-        if not history:
-            return schemas.Response(success=False, msg="记录不存在")
-        # 册除文件
-        if history.dest:
-            TransferChain(db).delete_files(Path(history.dest))
+    history = TransferHistory.get(db, history_in.id)
+    if not history:
+        return schemas.Response(success=False, msg="记录不存在")
+    # 册除媒体库文件
+    if deletedest and history.dest:
+        TransferChain(db).delete_files(Path(history.dest))
+    # 删除源文件
+    if deletesrc and history.src:
+        TransferChain(db).delete_files(Path(history.src))
     # 删除记录
     TransferHistory.delete(db, history_in.id)
     return schemas.Response(success=True)

app/api/endpoints/login.py

@@ -1,4 +1,3 @@
-import random
 from datetime import timedelta
 from typing import Any
 
@@ -15,7 +14,7 @@ from app.core.security import get_password_hash
 from app.db import get_db
 from app.db.models.user import User
 from app.log import logger
-from app.utils.http import RequestUtils
+from app.utils.web import WebUtils
 
 router = APIRouter()
 
@@ -67,21 +66,10 @@ def bing_wallpaper() -> Any:
     """
     获取Bing每日壁纸
     """
-    url = "https://cn.bing.com/HPImageArchive.aspx?format=js&idx=0&n=1"
-    try:
-        resp = RequestUtils(timeout=5).get_res(url)
-    except Exception as err:
-        print(str(err))
-        return schemas.Response(success=False)
-    if resp and resp.status_code == 200:
-        try:
-            result = resp.json()
-            if isinstance(result, dict):
-                for image in result.get('images') or []:
-                    return schemas.Response(success=False,
-                                            message=f"https://cn.bing.com{image.get('url')}" if 'url' in image else '')
-        except Exception as err:
-            print(str(err))
+    url = WebUtils.get_bing_wallpaper()
+    if url:
+        return schemas.Response(success=False,
+                                message=url)
     return schemas.Response(success=False)
 
 
@@ -90,14 +78,10 @@ def tmdb_wallpaper(db: Session = Depends(get_db)) -> Any:
     """
     获取TMDB电影海报
     """
-    infos = TmdbChain(db).tmdb_trending()
-    if infos:
-        # 随机一个电影
-        while True:
-            info = random.choice(infos)
-            if info and info.get("backdrop_path"):
-                return schemas.Response(
-                    success=True,
-                    message=f"https://image.tmdb.org/t/p/original{info.get('backdrop_path')}"
-                )
+    wallpager = TmdbChain(db).get_random_wallpager()
+    if wallpager:
+        return schemas.Response(
+            success=True,
+            message=wallpager
+        )
     return schemas.Response(success=False)

app/api/endpoints/message.py

@@ -73,7 +73,9 @@ def read_switchs(_: schemas.TokenPayload = Depends(verify_token)) -> Any:
     switchs = SystemConfigOper().get(SystemConfigKey.NotificationChannels)
     if not switchs:
         for noti in NotificationType:
-            return_list.append(NotificationSwitch(mtype=noti.value, wechat=True, telegram=True, slack=True))
+            return_list.append(NotificationSwitch(mtype=noti.value, wechat=True,
+                                                  telegram=True, slack=True,
+                                                  synologychat=True))
     else:
         for switch in switchs:
             return_list.append(NotificationSwitch(**switch))

app/api/endpoints/plugin.py

@@ -1,12 +1,10 @@
 from typing import Any, List
 
 from fastapi import APIRouter, Depends
-from sqlalchemy.orm import Session
 
 from app import schemas
 from app.core.plugin import PluginManager
 from app.core.security import verify_token
-from app.db import get_db
 from app.db.systemconfig_oper import SystemConfigOper
 from app.schemas.types import SystemConfigKey
 

app/api/endpoints/site.py

@@ -5,7 +5,6 @@ from sqlalchemy.orm import Session
 from starlette.background import BackgroundTasks
 
 from app import schemas
-from app.chain.cookiecloud import CookieCloudChain
 from app.chain.site import SiteChain
 from app.chain.torrents import TorrentsChain
 from app.core.event import EventManager
@@ -15,19 +14,13 @@ from app.db.models.site import Site
 from app.db.models.siteicon import SiteIcon
 from app.db.systemconfig_oper import SystemConfigOper
 from app.helper.sites import SitesHelper
+from app.scheduler import Scheduler
 from app.schemas.types import SystemConfigKey, EventType
 from app.utils.string import StringUtils
 
 router = APIRouter()
 
 
-def start_cookiecloud_sync(db: Session):
-    """
-    后台启动CookieCloud站点同步
-    """
-    CookieCloudChain(db).process(manual=True)
-
-
 @router.get("/", summary="所有站点", response_model=List[schemas.Site])
 def read_sites(db: Session = Depends(get_db),
                _: schemas.TokenPayload = Depends(verify_token)) -> List[dict]:
@@ -101,12 +94,11 @@ def delete_site(
 
 @router.get("/cookiecloud", summary="CookieCloud同步", response_model=schemas.Response)
 def cookie_cloud_sync(background_tasks: BackgroundTasks,
-                      db: Session = Depends(get_db),
                       _: schemas.TokenPayload = Depends(verify_token)) -> Any:
     """
     运行CookieCloud同步站点信息
     """
-    background_tasks.add_task(start_cookiecloud_sync, db)
+    background_tasks.add_task(Scheduler().start, job_id="cookiecloud")
     return schemas.Response(success=True, message="CookieCloud同步任务已启动！")
 
 
@@ -119,7 +111,8 @@ def cookie_cloud_sync(db: Session = Depends(get_db),
     Site.reset(db)
     SystemConfigOper().set(SystemConfigKey.IndexerSites, [])
     SystemConfigOper().set(SystemConfigKey.RssSites, [])
-    CookieCloudChain().process(manual=True)
+    # 启动定时服务
+    Scheduler().start("cookiecloud", manual=True)
     # 插件站点删除
     EventManager().send_event(EventType.SiteDeleted,
                               {
@@ -234,14 +227,14 @@ def read_rss_sites(db: Session = Depends(get_db)) -> List[dict]:
     获取站点列表
     """
     # 选中的rss站点
-    rss_sites = SystemConfigOper().get(SystemConfigKey.RssSites)
+    selected_sites = SystemConfigOper().get(SystemConfigKey.RssSites) or []
     # 所有站点
     all_site = Site.list_order_by_pri(db)
-    if not rss_sites or not all_site:
+    if not selected_sites or not all_site:
         return []
 
     # 选中的rss站点
-    rss_sites = [site for site in all_site if site and site.id in rss_sites]
+    rss_sites = [site for site in all_site if site and site.id in selected_sites]
     return rss_sites
 
 

app/api/endpoints/subscribe.py

@@ -1,5 +1,5 @@
 import json
-from typing import List, Any, Optional
+from typing import List, Any
 
 from fastapi import APIRouter, Request, BackgroundTasks, Depends, HTTPException, Header
 from sqlalchemy.orm import Session
@@ -12,6 +12,7 @@ from app.db import get_db
 from app.db.models.subscribe import Subscribe
 from app.db.models.user import User
 from app.db.userauth import get_current_active_user
+from app.scheduler import Scheduler
 from app.schemas.types import MediaType
 
 router = APIRouter()
@@ -26,13 +27,6 @@ def start_subscribe_add(db: Session, title: str, year: str,
                            mtype=mtype, tmdbid=tmdbid, season=season, username=username)
 
 
-def start_subscribe_search(db: Session, sid: Optional[int], state: Optional[str]):
-    """
-    启动订阅搜索任务
-    """
-    SubscribeChain(db).search(sid=sid, state=state, manual=True)
-
-
 @router.get("/", summary="所有订阅", response_model=List[schemas.Subscribe])
 def read_subscribes(
         db: Session = Depends(get_db),
@@ -138,6 +132,57 @@ def subscribe_mediaid(
     return result if result else Subscribe()
 
 
+@router.get("/refresh", summary="刷新订阅", response_model=schemas.Response)
+def refresh_subscribes(
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    刷新所有订阅
+    """
+    Scheduler().start("subscribe_refresh")
+    return schemas.Response(success=True)
+
+
+@router.get("/check", summary="刷新订阅 TMDB 信息", response_model=schemas.Response)
+def check_subscribes(
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    刷新订阅 TMDB 信息
+    """
+    Scheduler().start("subscribe_tmdb")
+    return schemas.Response(success=True)
+
+
+@router.get("/search", summary="搜索所有订阅", response_model=schemas.Response)
+def search_subscribes(
+        background_tasks: BackgroundTasks,
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    搜索所有订阅
+    """
+    background_tasks.add_task(
+        Scheduler().start,
+        job_id="subscribe_search",
+        sid=None, state='R'
+    )
+    return schemas.Response(success=True)
+
+
+@router.get("/search/{subscribe_id}", summary="搜索订阅", response_model=schemas.Response)
+def search_subscribe(
+        subscribe_id: int,
+        background_tasks: BackgroundTasks,
+        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
+    """
+    根据订阅编号搜索订阅
+    """
+    background_tasks.add_task(
+        Scheduler().start,
+        job_id="subscribe_search",
+        sid=subscribe_id, state=None
+    )
+    return schemas.Response(success=True)
+
+
 @router.get("/{subscribe_id}", summary="订阅详情", response_model=schemas.Subscribe)
 def read_subscribe(
         subscribe_id: int,
@@ -243,39 +288,3 @@ async def seerr_subscribe(request: Request, background_tasks: BackgroundTasks,
                                       username=user_name)
 
     return schemas.Response(success=True)
-
-
-@router.get("/refresh", summary="刷新订阅", response_model=schemas.Response)
-def refresh_subscribes(
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    刷新所有订阅
-    """
-    SubscribeChain(db).refresh()
-    return schemas.Response(success=True)
-
-
-@router.get("/search/{subscribe_id}", summary="搜索订阅", response_model=schemas.Response)
-def search_subscribe(
-        subscribe_id: int,
-        background_tasks: BackgroundTasks,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    搜索所有订阅
-    """
-    background_tasks.add_task(start_subscribe_search, db=db, sid=subscribe_id, state=None)
-    return schemas.Response(success=True)
-
-
-@router.get("/search", summary="搜索所有订阅", response_model=schemas.Response)
-def search_subscribes(
-        background_tasks: BackgroundTasks,
-        db: Session = Depends(get_db),
-        _: schemas.TokenPayload = Depends(verify_token)) -> Any:
-    """
-    搜索所有订阅
-    """
-    background_tasks.add_task(start_subscribe_search, db=db, sid=None, state='R')
-    return schemas.Response(success=True)

app/api/endpoints/system.py

@@ -1,9 +1,9 @@
 import json
 import time
-import tailer
 from datetime import datetime
 from typing import Union
 
+import tailer
 from fastapi import APIRouter, HTTPException, Depends
 from fastapi.responses import StreamingResponse
 from sqlalchemy.orm import Session
@@ -16,6 +16,7 @@ from app.db import get_db
 from app.db.systemconfig_oper import SystemConfigOper
 from app.helper.message import MessageHelper
 from app.helper.progress import ProgressHelper
+from app.scheduler import Scheduler
 from app.schemas.types import SystemConfigKey
 from app.utils.http import RequestUtils
 from app.utils.system import SystemUtils
@@ -25,7 +26,7 @@ router = APIRouter()
 
 
 @router.get("/env", summary="查询系统环境变量", response_model=schemas.Response)
-def get_setting(_: schemas.TokenPayload = Depends(verify_token)):
+def get_env_setting(_: schemas.TokenPayload = Depends(verify_token)):
     """
     查询系统环境变量，包括当前版本号
     """
@@ -83,7 +84,7 @@ def set_setting(key: str, value: Union[list, dict, str, int] = None,
 
 
 @router.get("/message", summary="实时消息")
-def get_progress(token: str):
+def get_message(token: str):
     """
     实时获取系统消息，返回格式为SSE
     """
@@ -169,31 +170,33 @@ def latest_version(_: schemas.TokenPayload = Depends(verify_token)):
     return schemas.Response(success=False)
 
 
-@router.get("/ruletest", summary="过滤规则测试", response_model=schemas.Response)
+@router.get("/ruletest", summary="优先级规则测试", response_model=schemas.Response)
 def ruletest(title: str,
              subtitle: str = None,
              ruletype: str = None,
              db: Session = Depends(get_db),
              _: schemas.TokenPayload = Depends(verify_token)):
     """
-    过滤规则测试，规则类型 1-订阅，2-洗版
+    过滤规则测试，规则类型 1-订阅，2-洗版，3-搜索
     """
     torrent = schemas.TorrentInfo(
         title=title,
         description=subtitle,
     )
     if ruletype == "2":
-        rule_string = SystemConfigOper().get(SystemConfigKey.FilterRules2)
+        rule_string = SystemConfigOper().get(SystemConfigKey.BestVersionFilterRules)
+    elif ruletype == "3":
+        rule_string = SystemConfigOper().get(SystemConfigKey.SearchFilterRules)
     else:
-        rule_string = SystemConfigOper().get(SystemConfigKey.FilterRules)
+        rule_string = SystemConfigOper().get(SystemConfigKey.SubscribeFilterRules)
     if not rule_string:
-        return schemas.Response(success=False, message="过滤规则未设置！")
+        return schemas.Response(success=False, message="优先级规则未设置！")
 
     # 过滤
     result = SearchChain(db).filter_torrents(rule_string=rule_string,
                                              torrent_list=[torrent])
     if not result:
-        return schemas.Response(success=False, message="不符合过滤规则！")
+        return schemas.Response(success=False, message="不符合优先级规则！")
     return schemas.Response(success=True, data={
         "priority": 100 - result[0].pri_order + 1
     })
@@ -209,3 +212,15 @@ def restart_system(_: schemas.TokenPayload = Depends(verify_token)):
     # 执行重启
     ret, msg = SystemUtils.restart()
     return schemas.Response(success=ret, message=msg)
+
+
+@router.get("/runscheduler", summary="运行服务", response_model=schemas.Response)
+def execute_command(jobid: str,
+                    _: schemas.TokenPayload = Depends(verify_token)):
+    """
+    执行命令
+    """
+    if not jobid:
+        return schemas.Response(success=False, message="命令不能为空！")
+    Scheduler().start(jobid)
+    return schemas.Response(success=True)

app/api/servarr.py

@@ -684,7 +684,7 @@ def arr_serie(apikey: str, tid: int, db: Session = Depends(get_db)) -> Any:
                 "monitored": True,
             }],
             year=subscribe.year,
-            remotePoster=subscribe.image,
+            remotePoster=subscribe.poster,
             tmdbId=subscribe.tmdbid,
             tvdbId=subscribe.tvdbid,
             imdbId=subscribe.imdbid,

app/chain/__init__.py

@@ -223,16 +223,19 @@ class ChainBase(metaclass=ABCMeta):
 
     def filter_torrents(self, rule_string: str,
                         torrent_list: List[TorrentInfo],
-                        season_episodes: Dict[int, list] = None) -> List[TorrentInfo]:
+                        season_episodes: Dict[int, list] = None,
+                        mediainfo: MediaInfo = None) -> List[TorrentInfo]:
         """
         过滤种子资源
         :param rule_string:  过滤规则
         :param torrent_list:  资源列表
         :param season_episodes:  季集数过滤 {season:[episodes]}
+        :param mediainfo:  识别的媒体信息
         :return: 过滤后的资源列表，添加资源优先级
         """
         return self.run_module("filter_torrents", rule_string=rule_string,
-                               torrent_list=torrent_list, season_episodes=season_episodes)
+                               torrent_list=torrent_list, season_episodes=season_episodes,
+                               mediainfo=mediainfo)
 
     def download(self, content: Union[Path, str], download_dir: Path, cookie: str,
                  episodes: Set[int] = None, category: str = None
@@ -333,14 +336,14 @@ class ChainBase(metaclass=ABCMeta):
         """
         return self.run_module("media_exists", mediainfo=mediainfo, itemid=itemid)
 
-    def refresh_mediaserver(self, mediainfo: MediaInfo, file_path: Path) -> Optional[bool]:
+    def refresh_mediaserver(self, mediainfo: MediaInfo, file_path: Path) -> None:
         """
         刷新媒体库
         :param mediainfo:  识别的媒体信息
         :param file_path:  文件路径
         :return: 成功或失败
         """
-        return self.run_module("refresh_mediaserver", mediainfo=mediainfo, file_path=file_path)
+        self.run_module("refresh_mediaserver", mediainfo=mediainfo, file_path=file_path)
 
     def post_message(self, message: Notification) -> None:
         """
@@ -388,22 +391,22 @@ class ChainBase(metaclass=ABCMeta):
         :param mediainfo:  识别的媒体信息
         :return: 成功或失败
         """
-        return self.run_module("scrape_metadata", path=path, mediainfo=mediainfo)
+        self.run_module("scrape_metadata", path=path, mediainfo=mediainfo)
 
     def register_commands(self, commands: Dict[str, dict]) -> None:
         """
         注册菜单命令
         """
-        return self.run_module("register_commands", commands=commands)
+        self.run_module("register_commands", commands=commands)
 
     def scheduler_job(self) -> None:
         """
         定时任务，每10分钟调用一次，模块实现该接口以实现定时服务
         """
-        return self.run_module("scheduler_job")
+        self.run_module("scheduler_job")
 
     def clear_cache(self) -> None:
         """
         清理缓存，模块实现该接口响应清理缓存事件
         """
-        return self.run_module("clear_cache")
+        self.run_module("clear_cache")

app/chain/cookiecloud.py

@@ -1,5 +1,5 @@
 import base64
-from typing import Tuple, Optional, Union
+from typing import Tuple, Optional
 from urllib.parse import urljoin
 
 from lxml import etree
@@ -16,7 +16,6 @@ from app.helper.message import MessageHelper
 from app.helper.rss import RssHelper
 from app.helper.sites import SitesHelper
 from app.log import logger
-from app.schemas import Notification, NotificationType, MessageChannel
 from app.utils.http import RequestUtils
 from app.utils.site import SiteUtils
 
@@ -40,21 +39,6 @@ class CookieCloudChain(ChainBase):
             password=settings.COOKIECLOUD_PASSWORD
         )
 
-    def remote_sync(self, channel: MessageChannel, userid: Union[int, str]):
-        """
-        远程触发同步站点，发送消息
-        """
-        self.post_message(Notification(channel=channel, mtype=NotificationType.SiteMessage,
-                                       title="开始同步CookieCloud站点 ...", userid=userid))
-        # 开始同步
-        success, msg = self.process()
-        if success:
-            self.post_message(Notification(channel=channel, mtype=NotificationType.SiteMessage,
-                                           title=f"同步站点成功，{msg}", userid=userid))
-        else:
-            self.post_message(Notification(channel=channel, mtype=NotificationType.SiteMessage,
-                                           title=f"同步站点失败：{msg}", userid=userid))
-
     def process(self, manual=False) -> Tuple[bool, str]:
         """
         通过CookieCloud同步站点Cookie

app/chain/dashboard.py

@@ -1,3 +1,5 @@
+from typing import Optional, List
+
 from app import schemas
 from app.chain import ChainBase
 
@@ -6,7 +8,7 @@ class DashboardChain(ChainBase):
     """
     各类仪表板统计处理链
     """
-    def media_statistic(self) -> schemas.Statistic:
+    def media_statistic(self) -> Optional[List[schemas.Statistic]]:
         """
         媒体数量统计
         """

app/chain/download.py

@@ -1,3 +1,5 @@
+import base64
+import json
 import re
 from pathlib import Path
 from typing import List, Optional, Tuple, Set, Dict, Union
@@ -15,6 +17,7 @@ from app.helper.torrent import TorrentHelper
 from app.log import logger
 from app.schemas import ExistMediaInfo, NotExistMediaInfo, DownloadingTorrent, Notification
 from app.schemas.types import MediaType, TorrentStatus, EventType, MessageChannel, NotificationType
+from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
 
 
@@ -79,8 +82,68 @@ class DownloadChain(ChainBase):
         下载种子文件，如果是磁力链，会返回磁力链接本身
         :return: 种子路径，种子目录名，种子文件清单
         """
+
+        def __get_redict_url(url: str, ua: str = None, cookie: str = None) -> Optional[str]:
+            """
+            获取下载链接， url格式：[base64]url
+            """
+            # 获取[]中的内容
+            m = re.search(r"\[(.*)](.*)", url)
+            if m:
+                # 参数
+                base64_str = m.group(1)
+                # URL
+                url = m.group(2)
+                if not base64_str:
+                    return url
+                # 解码参数
+                req_str = base64.b64decode(base64_str.encode('utf-8')).decode('utf-8')
+                req_params: Dict[str, dict] = json.loads(req_str)
+                if req_params.get('method') == 'get':
+                    # GET请求
+                    res = RequestUtils(
+                        ua=ua,
+                        cookies=cookie
+                    ).get_res(url, params=req_params.get('params'))
+                else:
+                    # POST请求
+                    res = RequestUtils(
+                        ua=ua,
+                        cookies=cookie
+                    ).post_res(url, params=req_params.get('params'))
+                if not res:
+                    return None
+                if not req_params.get('result'):
+                    return res.text
+                else:
+                    data = res.json()
+                    for key in str(req_params.get('result')).split("."):
+                        data = data.get(key)
+                        if not data:
+                            return None
+                    logger.info(f"获取到下载地址：{data}")
+                    return data
+            return None
+
+        # 获取下载链接
+        if not torrent.enclosure:
+            return None, "", []
+        if torrent.enclosure.startswith("magnet:"):
+            return torrent.enclosure, "", []
+
+        if torrent.enclosure.startswith("["):
+            # 需要解码获取下载地址
+            torrent_url = __get_redict_url(url=torrent.enclosure,
+                                           ua=torrent.site_ua,
+                                           cookie=torrent.site_cookie)
+        else:
+            torrent_url = torrent.enclosure
+        if not torrent_url:
+            logger.error(f"{torrent.title} 无法获取下载地址：{torrent.enclosure}！")
+            return None, "", []
+        # 下载种子文件
         torrent_file, content, download_folder, files, error_msg = self.torrent.download_torrent(
-            url=torrent.enclosure,
+            url=torrent_url,
             cookie=torrent.site_cookie,
             ua=torrent.site_ua,
             proxy=torrent.site_proxy)
@@ -90,7 +153,7 @@ class DownloadChain(ChainBase):
             return content, "", []
 
         if not torrent_file:
-            logger.error(f"下载种子文件失败：{torrent.title} - {torrent.enclosure}")
+            logger.error(f"下载种子文件失败：{torrent.title} - {torrent_url}")
             self.post_message(Notification(
                 channel=channel,
                 mtype=NotificationType.Manual,
@@ -122,7 +185,9 @@ class DownloadChain(ChainBase):
         _folder_name = ""
         if not torrent_file:
             # 下载种子文件，得到的可能是文件也可能是磁力链
-            content, _folder_name, _file_list = self.download_torrent(_torrent, userid=userid)
+            content, _folder_name, _file_list = self.download_torrent(_torrent,
+                                                                      channel=channel,
+                                                                      userid=userid)
             if not content:
                 return
         else:
@@ -225,7 +290,7 @@ class DownloadChain(ChainBase):
                 self.downloadhis.add_files(files_to_add)
 
             # 发送消息
-            self.post_download_message(meta=_meta, mediainfo=_media, torrent=_torrent, channel=channel)
+            self.post_download_message(meta=_meta, mediainfo=_media, torrent=_torrent, channel=channel, userid=userid)
             # 下载成功后处理
             self.download_added(context=context, download_dir=download_dir, torrent_path=torrent_file)
             # 广播事件
@@ -253,12 +318,14 @@ class DownloadChain(ChainBase):
                        contexts: List[Context],
                        no_exists: Dict[int, Dict[int, NotExistMediaInfo]] = None,
                        save_path: str = None,
+                       channel: str = None,
                        userid: str = None) -> Tuple[List[Context], Dict[int, Dict[int, NotExistMediaInfo]]]:
         """
         根据缺失数据，自动种子列表中组合择优下载
         :param contexts:  资源上下文列表
         :param no_exists:  缺失的剧集信息
         :param save_path:  保存路径
+        :param channel:  通知渠道
         :param userid:  用户ID
         :return: 已经下载的资源列表、剩余未下载到的剧集 no_exists[tmdb_id] = {season: NotExistMediaInfo}
         """
@@ -323,7 +390,8 @@ class DownloadChain(ChainBase):
         # 如果是电影，直接下载
         for context in contexts:
             if context.media_info.type == MediaType.MOVIE:
-                if self.download_single(context, save_path=save_path, userid=userid):
+                if self.download_single(context, save_path=save_path,
+                                        channel=channel, userid=userid):
                     # 下载成功
                     downloaded_list.append(context)
 
@@ -390,11 +458,13 @@ class DownloadChain(ChainBase):
                                         context=context,
                                         torrent_file=content if isinstance(content, Path) else None,
                                         save_path=save_path,
+                                        channel=channel,
                                         userid=userid
                                     )
                             else:
                                 # 下载
-                                download_id = self.download_single(context, save_path=save_path, userid=userid)
+                                download_id = self.download_single(context, save_path=save_path,
+                                                                   channel=channel, userid=userid)
 
                             if download_id:
                                 # 下载成功
@@ -452,7 +522,8 @@ class DownloadChain(ChainBase):
                             # 为需要集的子集则下载
                             if torrent_episodes.issubset(set(need_episodes)):
                                 # 下载
-                                download_id = self.download_single(context, save_path=save_path, userid=userid)
+                                download_id = self.download_single(context, save_path=save_path,
+                                                                   channel=channel, userid=userid)
                                 if download_id:
                                     # 下载成功
                                     downloaded_list.append(context)
@@ -508,7 +579,7 @@ class DownloadChain(ChainBase):
                                 and len(meta.season_list) == 1 \
                                 and meta.season_list[0] == need_season:
                             # 检查种子看是否有需要的集
-                            content, _, torrent_files = self.download_torrent(torrent, userid=userid)
+                            content, _, torrent_files = self.download_torrent(torrent)
                             if not content:
                                 continue
                             if isinstance(content, str):
@@ -529,6 +600,7 @@ class DownloadChain(ChainBase):
                                 torrent_file=content if isinstance(content, Path) else None,
                                 episodes=selected_episodes,
                                 save_path=save_path,
+                                channel=channel,
                                 userid=userid
                             )
                             if not download_id:

app/chain/mediaserver.py

@@ -10,7 +10,6 @@ from app.core.config import settings
 from app.db import SessionFactory
 from app.db.mediaserver_oper import MediaServerOper
 from app.log import logger
-from app.schemas import MessageChannel, Notification
 
 lock = threading.Lock()
 
@@ -23,33 +22,23 @@ class MediaServerChain(ChainBase):
     def __init__(self, db: Session = None):
         super().__init__(db)
 
-    def librarys(self) -> List[schemas.MediaServerLibrary]:
+    def librarys(self, server: str) -> List[schemas.MediaServerLibrary]:
         """
         获取媒体服务器所有媒体库
         """
-        return self.run_module("mediaserver_librarys")
+        return self.run_module("mediaserver_librarys", server=server)
 
-    def items(self, library_id: Union[str, int]) -> Generator:
+    def items(self, server: str, library_id: Union[str, int]) -> Generator:
         """
         获取媒体服务器所有项目
         """
-        return self.run_module("mediaserver_items", library_id=library_id)
+        return self.run_module("mediaserver_items", server=server, library_id=library_id)
 
-    def episodes(self, item_id: Union[str, int]) -> List[schemas.MediaServerSeasonInfo]:
+    def episodes(self, server: str, item_id: Union[str, int]) -> List[schemas.MediaServerSeasonInfo]:
         """
         获取媒体服务器剧集信息
         """
-        return self.run_module("mediaserver_tv_episodes", item_id=item_id)
-
-    def remote_sync(self, channel: MessageChannel, userid: Union[int, str]):
-        """
-        同步豆瓣想看数据，发送消息
-        """
-        self.post_message(Notification(channel=channel,
-                                       title="开始媒体服务器 ...", userid=userid))
-        self.sync()
-        self.post_message(Notification(channel=channel,
-                                       title="同步媒体服务器完成！", userid=userid))
+        return self.run_module("mediaserver_tv_episodes", server=server, item_id=item_id)
 
     def sync(self):
         """
@@ -59,37 +48,49 @@ class MediaServerChain(ChainBase):
             # 媒体服务器同步使用独立的会话
             _db = SessionFactory()
             _dbOper = MediaServerOper(_db)
-            logger.info("开始同步媒体库数据 ...")
             # 汇总统计
             total_count = 0
             # 清空登记薄
             _dbOper.empty(server=settings.MEDIASERVER)
-            for library in self.librarys():
-                logger.info(f"正在同步媒体库 {library.name} ...")
-                library_count = 0
-                for item in self.items(library.id):
-                    if not item:
+            # 同步黑名单
+            sync_blacklist = settings.MEDIASERVER_SYNC_BLACKLIST.split(
+                ",") if settings.MEDIASERVER_SYNC_BLACKLIST else []
+            # 设置的媒体服务器
+            if not settings.MEDIASERVER:
+                return
+            mediaservers = settings.MEDIASERVER.split(",")
+            # 遍历媒体服务器
+            for mediaserver in mediaservers:
+                logger.info(f"开始同步媒体库 {mediaserver} 的数据 ...")
+                for library in self.librarys(mediaserver):
+                    # 同步黑名单 跳过
+                    if library.name in sync_blacklist:
                         continue
-                    if not item.item_id:
-                        continue
-                    # 计数
-                    library_count += 1
-                    seasoninfo = {}
-                    # 类型
-                    item_type = "电视剧" if item.item_type in ['Series', 'show'] else "电影"
-                    if item_type == "电视剧":
-                        # 查询剧集信息
-                        espisodes_info = self.episodes(item.item_id) or []
-                        for episode in espisodes_info:
-                            seasoninfo[episode.season] = episode.episodes
-                    # 插入数据
-                    item_dict = item.dict()
-                    item_dict['seasoninfo'] = json.dumps(seasoninfo)
-                    item_dict['item_type'] = item_type
-                    _dbOper.add(**item_dict)
-                logger.info(f"媒体库 {library.name} 同步完成，共同步数量：{library_count}")
-                # 总数累加
-                total_count += library_count
+                    logger.info(f"正在同步 {mediaserver} 媒体库 {library.name} ...")
+                    library_count = 0
+                    for item in self.items(mediaserver, library.id):
+                        if not item:
+                            continue
+                        if not item.item_id:
+                            continue
+                        # 计数
+                        library_count += 1
+                        seasoninfo = {}
+                        # 类型
+                        item_type = "电视剧" if item.item_type in ['Series', 'show'] else "电影"
+                        if item_type == "电视剧":
+                            # 查询剧集信息
+                            espisodes_info = self.episodes(mediaserver, item.item_id) or []
+                            for episode in espisodes_info:
+                                seasoninfo[episode.season] = episode.episodes
+                        # 插入数据
+                        item_dict = item.dict()
+                        item_dict['seasoninfo'] = json.dumps(seasoninfo)
+                        item_dict['item_type'] = item_type
+                        _dbOper.add(**item_dict)
+                    logger.info(f"{mediaserver} 媒体库 {library.name} 同步完成，共同步数量：{library_count}")
+                    # 总数累加
+                    total_count += library_count
             # 关闭数据库连接
             if _db:
                 _db.close()

app/chain/message.py

@@ -348,6 +348,7 @@ class MessageChain(ChainBase):
         # 批量下载
         downloads, lefts = self.downloadchain.batch_download(contexts=cache_list,
                                                              no_exists=no_exists,
+                                                             channel=channel,
                                                              userid=userid)
         if downloads and not lefts:
             # 全部下载完成

app/chain/search.py

@@ -1,4 +1,5 @@
 import pickle
+import re
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from datetime import datetime
 from typing import Dict
@@ -80,7 +81,8 @@ class SearchChain(ChainBase):
                 keyword: str = None,
                 no_exists: Dict[int, Dict[int, NotExistMediaInfo]] = None,
                 sites: List[int] = None,
-                filter_rule: str = None,
+                priority_rule: str = None,
+                filter_rule: Dict[str, str] = None,
                 area: str = "title") -> List[Context]:
         """
         根据媒体信息搜索种子资源，精确匹配，应用过滤规则，同时根据no_exists过滤本地已存在的资源
@@ -88,6 +90,7 @@ class SearchChain(ChainBase):
         :param keyword: 搜索关键词
         :param no_exists: 缺失的媒体信息
         :param sites: 站点ID列表，为空时搜索所有站点
+        :param priority_rule: 优先级规则，为空时使用搜索优先级规则
         :param filter_rule: 过滤规则，为空是使用默认过滤规则
         :param area: 搜索范围，title or imdbid
         """
@@ -128,19 +131,26 @@ class SearchChain(ChainBase):
             logger.warn(f'{keyword or mediainfo.title} 未搜索到资源')
             return []
         # 过滤种子
-        if filter_rule is None:
-            # 取默认过滤规则
-            filter_rule = self.systemconfig.get(SystemConfigKey.FilterRules)
-        if filter_rule:
-            logger.info(f'开始过滤资源，当前规则：{filter_rule} ...')
-            result: List[TorrentInfo] = self.filter_torrents(rule_string=filter_rule,
+        if priority_rule is None:
+            # 取搜索优先级规则
+            priority_rule = self.systemconfig.get(SystemConfigKey.SearchFilterRules)
+        if priority_rule:
+            logger.info(f'开始过滤资源，当前规则：{priority_rule} ...')
+            result: List[TorrentInfo] = self.filter_torrents(rule_string=priority_rule,
                                                              torrent_list=torrents,
-                                                             season_episodes=season_episodes)
+                                                             season_episodes=season_episodes,
+                                                             mediainfo=mediainfo)
             if result is not None:
                 torrents = result
             if not torrents:
-                logger.warn(f'{keyword or mediainfo.title} 没有符合过滤条件的资源')
+                logger.warn(f'{keyword or mediainfo.title} 没有符合优先级规则的资源')
                 return []
+        # 使用默认过滤规则再次过滤
+        torrents = self.filter_torrents_by_rule(torrents=torrents,
+                                                filter_rule=filter_rule)
+        if not torrents:
+            logger.warn(f'{keyword or mediainfo.title} 没有符合过滤规则的资源')
+            return []
         # 匹配的资源
         _match_torrents = []
         # 总数
@@ -185,19 +195,30 @@ class SearchChain(ChainBase):
                                                      str(int(mediainfo.year) + 1)]:
                             logger.warn(f'{torrent.site_name} - {torrent.title} 年份不匹配')
                             continue
-                # 比对标题
+                # 比对标题和原语种标题
                 meta_name = StringUtils.clear_upper(torrent_meta.name)
                 if meta_name in [
                     StringUtils.clear_upper(mediainfo.title),
                     StringUtils.clear_upper(mediainfo.original_title)
                 ]:
-                    logger.info(f'{mediainfo.title} 匹配到资源：{torrent.site_name} - {torrent.title}')
+                    logger.info(f'{mediainfo.title} 通过标题匹配到资源：{torrent.site_name} - {torrent.title}')
                     _match_torrents.append(torrent)
                     continue
+                # 在副标题中判断是否存在标题与原语种标题
+                if torrent.description:
+                    subtitle = torrent.description.split()
+                    if (StringUtils.is_chinese(mediainfo.title)
+                        and str(mediainfo.title) in subtitle) \
+                            or (StringUtils.is_chinese(mediainfo.original_title)
+                                and str(mediainfo.original_title) in subtitle):
+                        logger.info(f'{mediainfo.title} 通过副标题匹配到资源：{torrent.site_name} - {torrent.title}，'
+                                    f'副标题：{torrent.description}')
+                        _match_torrents.append(torrent)
+                        continue
                 # 比对别名和译名
                 for name in mediainfo.names:
                     if StringUtils.clear_upper(name) == meta_name:
-                        logger.info(f'{mediainfo.title} 匹配到资源：{torrent.site_name} - {torrent.title}')
+                        logger.info(f'{mediainfo.title} 通过别名或译名匹配到资源：{torrent.site_name} - {torrent.title}')
                         _match_torrents.append(torrent)
                         break
                 else:
@@ -236,14 +257,14 @@ class SearchChain(ChainBase):
         """
         # 未开启的站点不搜索
         indexer_sites = []
+
         # 配置的索引站点
-        if sites:
-            config_indexers = [str(sid) for sid in sites]
-        else:
-            config_indexers = [str(sid) for sid in self.systemconfig.get(SystemConfigKey.IndexerSites) or []]
+        if not sites:
+            sites = self.systemconfig.get(SystemConfigKey.IndexerSites) or []
+
         for indexer in self.siteshelper.get_indexers():
             # 检查站点索引开关
-            if not config_indexers or str(indexer.get("id")) in config_indexers:
+            if not sites or indexer.get("id") in sites:
                 # 站点流控
                 state, msg = self.siteshelper.check(indexer.get("domain"))
                 if state:
@@ -253,6 +274,7 @@ class SearchChain(ChainBase):
         if not indexer_sites:
             logger.warn('未开启任何有效站点，无法搜索资源')
             return []
+
         # 开始进度
         self.progress.start(ProgressKey.Search)
         # 开始计时
@@ -294,3 +316,44 @@ class SearchChain(ChainBase):
         self.progress.end(ProgressKey.Search)
         # 返回
         return results
+
+    def filter_torrents_by_rule(self,
+                                torrents: List[TorrentInfo],
+                                filter_rule: Dict[str, str] = None
+                                ) -> List[TorrentInfo]:
+        """
+        使用过滤规则过滤种子
+        :param torrents: 种子列表
+        :param filter_rule: 过滤规则
+        """
+
+        # 取默认过滤规则
+        if not filter_rule:
+            filter_rule = self.systemconfig.get(SystemConfigKey.DefaultFilterRules)
+        if not filter_rule:
+            return torrents
+        # 包含
+        include = filter_rule.get("include")
+        # 排除
+        exclude = filter_rule.get("exclude")
+
+        def __filter_torrent(t: TorrentInfo) -> bool:
+            """
+            过滤种子
+            """
+            # 包含
+            if include:
+                if not re.search(r"%s" % include,
+                                 f"{t.title} {t.description}", re.I):
+                    logger.info(f"{t.title} 不匹配包含规则 {include}")
+                    return False
+            # 排除
+            if exclude:
+                if re.search(r"%s" % exclude,
+                             f"{t.title} {t.description}", re.I):
+                    logger.info(f"{t.title} 匹配排除规则 {exclude}")
+                    return False
+            return True
+
+        # 使用默认过滤规则再次过滤
+        return list(filter(lambda t: __filter_torrent(t), torrents))

app/chain/site.py

@@ -1,3 +1,4 @@
+import re
 from typing import Union, Tuple
 
 from sqlalchemy.orm import Session
@@ -28,6 +29,66 @@ class SiteChain(ChainBase):
         self.cookiehelper = CookieHelper()
         self.message = MessageHelper()
 
+        # 特殊站点登录验证
+        self.special_site_test = {
+            "zhuque.in": self.__zhuque_test,
+            # "m-team.io": self.__mteam_test,
+        }
+
+    @staticmethod
+    def __zhuque_test(site: Site) -> Tuple[bool, str]:
+        """
+        判断站点是否已经登陆：zhuique
+        """
+        # 获取token
+        token = None
+        res = RequestUtils(
+            ua=site.ua,
+            cookies=site.cookie,
+            proxies=settings.PROXY if site.proxy else None,
+            timeout=15
+        ).get_res(url=site.url)
+        if res and res.status_code == 200:
+            csrf_token = re.search(r'<meta name="x-csrf-token" content="(.+?)">', res.text)
+            if csrf_token:
+                token = csrf_token.group(1)
+        if not token:
+            return False, "无法获取Token"
+        # 调用查询用户信息接口
+        user_res = RequestUtils(
+            headers={
+                'X-CSRF-TOKEN': token,
+                "Content-Type": "application/json; charset=utf-8",
+                "User-Agent": f"{site.ua}"
+            },
+            cookies=site.cookie,
+            proxies=settings.PROXY if site.proxy else None,
+            timeout=15
+        ).get_res(url=f"{site.url}api/user/getInfo")
+        if user_res and user_res.status_code == 200:
+            user_info = user_res.json()
+            if user_info and user_info.get("data"):
+                return True, "连接成功"
+        return False, "Cookie已失效"
+
+    @staticmethod
+    def __mteam_test(site: Site) -> Tuple[bool, str]:
+        """
+        判断站点是否已经登陆：m-team
+        """
+        url = f"{site.url}api/member/profile"
+        res = RequestUtils(
+            ua=site.ua,
+            cookies=site.cookie,
+            proxies=settings.PROXY if site.proxy else None,
+            timeout=15
+        ).post_res(url=url)
+        if res and res.status_code == 200:
+            user_info = res.json()
+            if user_info and user_info.get("data"):
+                return True, "连接成功"
+        return False, "Cookie已失效"
+
     def test(self, url: str) -> Tuple[bool, str]:
         """
         测试站点是否可用
@@ -39,6 +100,12 @@ class SiteChain(ChainBase):
         site_info = self.siteoper.get_by_domain(domain)
         if not site_info:
             return False, f"站点【{url}】不存在"
+
+        # 特殊站点测试
+        if self.special_site_test.get(domain):
+            return self.special_site_test[domain](site_info)
+
+        # 通用站点测试
         site_url = site_info.url
         site_cookie = site_info.cookie
         ua = site_info.ua

app/chain/subscribe.py

@@ -132,45 +132,6 @@ class SubscribeChain(ChainBase):
             return True
         return False
 
-    def remote_refresh(self, channel: MessageChannel, userid: Union[str, int] = None):
-        """
-        远程刷新订阅，发送消息
-        """
-        self.post_message(Notification(channel=channel,
-                                       title=f"开始刷新订阅 ...", userid=userid))
-        self.refresh()
-        self.post_message(Notification(channel=channel,
-                                       title=f"订阅刷新完成！", userid=userid))
-
-    def remote_search(self, arg_str: str, channel: MessageChannel, userid: Union[str, int] = None):
-        """
-        远程搜索订阅，发送消息
-        """
-        if arg_str and not str(arg_str).isdigit():
-            self.post_message(Notification(channel=channel,
-                                           title="请输入正确的命令格式：/subscribe_search [id]，"
-                                                 "[id]为订阅编号，不输入订阅编号时搜索所有订阅", userid=userid))
-            return
-        if arg_str:
-            sid = int(arg_str)
-            subscribe = self.subscribeoper.get(sid)
-            if not subscribe:
-                self.post_message(Notification(channel=channel,
-                                               title=f"订阅编号 {sid} 不存在！", userid=userid))
-                return
-            self.post_message(Notification(channel=channel,
-                                           title=f"开始搜索 {subscribe.name} ...", userid=userid))
-            # 搜索订阅
-            self.search(sid=int(arg_str))
-            self.post_message(Notification(channel=channel,
-                                           title=f"{subscribe.name} 搜索完成！", userid=userid))
-        else:
-            self.post_message(Notification(channel=channel,
-                                           title=f"开始搜索所有订阅 ...", userid=userid))
-            self.search(state='R')
-            self.post_message(Notification(channel=channel,
-                                           title=f"订阅搜索完成！", userid=userid))
-
     def search(self, sid: int = None, state: str = 'N', manual: bool = False):
         """
         订阅搜索
@@ -262,22 +223,31 @@ class SubscribeChain(ChainBase):
                 sites = json.loads(subscribe.sites)
             else:
                 sites = None
-            # 过滤规则
+            # 优先级过滤规则
             if subscribe.best_version:
-                filter_rule = self.systemconfig.get(SystemConfigKey.FilterRules2)
+                priority_rule = self.systemconfig.get(SystemConfigKey.BestVersionFilterRules)
             else:
-                filter_rule = self.systemconfig.get(SystemConfigKey.FilterRules)
+                priority_rule = self.systemconfig.get(SystemConfigKey.SubscribeFilterRules)
+            # 默认过滤规则
+            if subscribe.include or subscribe.exclude:
+                filter_rule = {
+                    "include": subscribe.include,
+                    "exclude": subscribe.exclude
+                }
+            else:
+                filter_rule = self.systemconfig.get(SystemConfigKey.DefaultFilterRules)
             # 搜索，同时电视剧会过滤掉不需要的剧集
             contexts = self.searchchain.process(mediainfo=mediainfo,
                                                 keyword=subscribe.keyword,
                                                 no_exists=no_exists,
                                                 sites=sites,
+                                                priority_rule=priority_rule,
                                                 filter_rule=filter_rule)
             if not contexts:
                 logger.warn(f'订阅 {subscribe.keyword or subscribe.name} 未搜索到资源')
                 if meta.type == MediaType.TV:
                     # 未搜索到资源，但本地缺失可能有变化，更新订阅剩余集数
-                    self.__upate_lack_episodes(lefts=no_exists, subscribe=subscribe, mediainfo=mediainfo)
+                    self.__update_lack_episodes(lefts=no_exists, subscribe=subscribe, mediainfo=mediainfo)
                 continue
             # 过滤
             matched_contexts = []
@@ -285,16 +255,6 @@ class SubscribeChain(ChainBase):
                 torrent_meta = context.meta_info
                 torrent_info = context.torrent_info
                 torrent_mediainfo = context.media_info
-                # 包含
-                if subscribe.include:
-                    if not re.search(r"%s" % subscribe.include,
-                                     f"{torrent_info.title} {torrent_info.description}", re.I):
-                        continue
-                # 排除
-                if subscribe.exclude:
-                    if re.search(r"%s" % subscribe.exclude,
-                                 f"{torrent_info.title} {torrent_info.description}", re.I):
-                        continue
                 # 非洗版
                 if not subscribe.best_version:
                     # 如果是电视剧过滤掉已经下载的集数
@@ -308,12 +268,17 @@ class SubscribeChain(ChainBase):
                         if torrent_meta.episode_list:
                             logger.info(f'{subscribe.name} 正在洗版，{torrent_info.title} 不是整季')
                             continue
+                    # 优先级小于已下载优先级的不要
+                    if subscribe.current_priority \
+                            and torrent_info.pri_order < subscribe.current_priority:
+                        logger.info(f'{subscribe.name} 正在洗版，{torrent_info.title} 优先级低于已下载优先级')
+                        continue
                 matched_contexts.append(context)
             if not matched_contexts:
                 logger.warn(f'订阅 {subscribe.name} 没有符合过滤条件的资源')
                 # 非洗版未搜索到资源，但本地缺失可能有变化，更新订阅剩余集数
                 if meta.type == MediaType.TV and not subscribe.best_version:
-                    self.__upate_lack_episodes(lefts=no_exists, subscribe=subscribe, mediainfo=mediainfo)
+                    self.__update_lack_episodes(lefts=no_exists, subscribe=subscribe, mediainfo=mediainfo)
                 continue
             # 自动下载
             downloads, lefts = self.downloadchain.batch_download(contexts=matched_contexts,
@@ -330,18 +295,18 @@ class SubscribeChain(ChainBase):
                                              mediainfo=mediainfo, downloads=downloads)
             else:
                 # 未完成下载
-                logger.info(f'{mediainfo.title_year} 未下载未完整，继续订阅 ...')
+                logger.info(f'{mediainfo.title_year} 未下载完整，继续订阅 ...')
                 if meta.type == MediaType.TV and not subscribe.best_version:
                     # 更新订阅剩余集数和时间
                     update_date = True if downloads else False
-                    self.__upate_lack_episodes(lefts=lefts, subscribe=subscribe,
-                                               mediainfo=mediainfo, update_date=update_date)
+                    self.__update_lack_episodes(lefts=lefts, subscribe=subscribe,
+                                                mediainfo=mediainfo, update_date=update_date)
         # 手动触发时发送系统消息
         if manual:
             if sid:
                 self.message.put(f'订阅 {subscribes[0].name} 搜索完成！')
             else:
-                self.message.put(f'所有订阅搜索完成！')
+                self.message.put('所有订阅搜索完成！')
 
     def finish_subscribe_or_not(self, subscribe: Subscribe, meta: MetaInfo,
                                 mediainfo: MediaInfo, downloads: List[Context]):
@@ -482,6 +447,10 @@ class SubscribeChain(ChainBase):
                     }
                 else:
                     no_exists = {}
+            # 默认过滤规则
+            default_filter = self.systemconfig.get(SystemConfigKey.DefaultFilterRules) or {}
+            include = subscribe.include or default_filter.get("include")
+            exclude = subscribe.exclude or default_filter.get("exclude")
             # 遍历缓存种子
             _match_context = []
             for domain, contexts in torrents.items():
@@ -494,21 +463,24 @@ class SubscribeChain(ChainBase):
                     if torrent_mediainfo.tmdb_id != mediainfo.tmdb_id \
                             or torrent_mediainfo.type != mediainfo.type:
                         continue
-                    # 过滤规则
+                    # 优先级过滤规则
                     if subscribe.best_version:
-                        filter_rule = self.systemconfig.get(SystemConfigKey.FilterRules2)
+                        filter_rule = self.systemconfig.get(SystemConfigKey.BestVersionFilterRules)
                     else:
-                        filter_rule = self.systemconfig.get(SystemConfigKey.FilterRules)
+                        filter_rule = self.systemconfig.get(SystemConfigKey.SubscribeFilterRules)
                     result: List[TorrentInfo] = self.filter_torrents(
                         rule_string=filter_rule,
-                        torrent_list=[torrent_info])
+                        torrent_list=[torrent_info],
+                        mediainfo=torrent_mediainfo)
                     if result is not None and not result:
                         # 不符合过滤规则
+                        logger.info(f"{torrent_info.title} 不匹配当前过滤规则")
                         continue
                     # 不在订阅站点范围的不处理
                     if subscribe.sites:
                         sub_sites = json.loads(subscribe.sites)
                         if sub_sites and torrent_info.site not in sub_sites:
+                            logger.info(f"{torrent_info.title} 不符合 {torrent_mediainfo.title_year} 订阅站点要求")
                             continue
                     # 如果是电视剧
                     if torrent_mediainfo.type == MediaType.TV:
@@ -551,14 +523,16 @@ class SubscribeChain(ChainBase):
                                     logger.info(f'{subscribe.name} 正在洗版，{torrent_info.title} 不是整季')
                                     continue
                     # 包含
-                    if subscribe.include:
-                        if not re.search(r"%s" % subscribe.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}")
                             continue
                     # 排除
-                    if subscribe.exclude:
-                        if re.search(r"%s" % subscribe.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}")
                             continue
                     # 匹配成功
                     logger.info(f'{mediainfo.title_year} 匹配成功：{torrent_info.title}')
@@ -580,12 +554,12 @@ class SubscribeChain(ChainBase):
                     if meta.type == MediaType.TV and not subscribe.best_version:
                         update_date = True if downloads else False
                         # 未完成下载，计算剩余集数
-                        self.__upate_lack_episodes(lefts=lefts, subscribe=subscribe,
-                                                   mediainfo=mediainfo, update_date=update_date)
+                        self.__update_lack_episodes(lefts=lefts, subscribe=subscribe,
+                                                    mediainfo=mediainfo, update_date=update_date)
             else:
                 if meta.type == MediaType.TV:
                     # 未搜索到资源，但本地缺失可能有变化，更新订阅剩余集数
-                    self.__upate_lack_episodes(lefts=no_exists, subscribe=subscribe, mediainfo=mediainfo)
+                    self.__update_lack_episodes(lefts=no_exists, subscribe=subscribe, mediainfo=mediainfo)
 
     def check(self):
         """
@@ -609,18 +583,16 @@ class SubscribeChain(ChainBase):
             if not mediainfo:
                 logger.warn(f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}')
                 continue
-            if not mediainfo.seasons:
-                continue
-            # 获取当前季的总集数
+            # 对于电视剧，获取当前季的总集数
             episodes = mediainfo.seasons.get(subscribe.season) or []
-            if len(episodes) > subscribe.total_episode or 0:
+            if len(episodes) > (subscribe.total_episode or 0):
                 total_episode = len(episodes)
                 lack_episode = subscribe.lack_episode + (total_episode - subscribe.total_episode)
-                logger.info(f'订阅 {subscribe.name} 总集数变化，更新总集数为{total_episode}，缺失集数为{lack_episode} ...')
+                logger.info(
+                    f'订阅 {subscribe.name} 总集数变化，更新总集数为{total_episode}，缺失集数为{lack_episode} ...')
             else:
                 total_episode = subscribe.total_episode
                 lack_episode = subscribe.lack_episode
-                logger.info(f'订阅 {subscribe.name} 总集数未变化')
             # 更新TMDB信息
             self.subscribeoper.update(subscribe.id, {
                 "name": mediainfo.title,
@@ -677,10 +649,10 @@ class SubscribeChain(ChainBase):
             return True
         return False
 
-    def __upate_lack_episodes(self, lefts: Dict[int, Dict[int, NotExistMediaInfo]],
-                              subscribe: Subscribe,
-                              mediainfo: MediaInfo,
-                              update_date: bool = False):
+    def __update_lack_episodes(self, lefts: Dict[int, Dict[int, NotExistMediaInfo]],
+                               subscribe: Subscribe,
+                               mediainfo: MediaInfo,
+                               update_date: bool = False):
         """
         更新订阅剩余集数
         """
@@ -765,7 +737,7 @@ class SubscribeChain(ChainBase):
                                  total_episode: int,
                                  start_episode: int):
         """
-        根据订阅开始集数和总结数，结合TMDB信息计算当前订阅的缺失集数
+        根据订阅开始集数和总集数，结合TMDB信息计算当前订阅的缺失集数
         :param no_exists: 缺失季集列表
         :param tmdb_id: TMDB ID
         :param begin_season: 开始季

app/chain/tmdb.py

@@ -1,11 +1,15 @@
+import random
 from typing import Optional, List
 
+from cachetools import cached, TTLCache
+
 from app import schemas
 from app.chain import ChainBase
 from app.schemas import MediaType
+from app.utils.singleton import Singleton
 
 
-class TmdbChain(ChainBase):
+class TmdbChain(ChainBase, metaclass=Singleton):
     """
     TheMovieDB处理链
     """
@@ -106,3 +110,17 @@ class TmdbChain(ChainBase):
         :param page:  页码
         """
         return self.run_module("person_credits", person_id=person_id, page=page)
+
+    @cached(cache=TTLCache(maxsize=1, ttl=3600))
+    def get_random_wallpager(self):
+        """
+        获取随机壁纸，缓存1个小时
+        """
+        infos = self.tmdb_trending()
+        if infos:
+            # 随机一个电影
+            while True:
+                info = random.choice(infos)
+                if info and info.get("backdrop_path"):
+                    return f"https://image.tmdb.org/t/p/original{info.get('backdrop_path')}"
+        return None

app/chain/torrents.py

@@ -60,7 +60,7 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
         else:
             return self.load_cache(self._rss_file) or {}
 
-    @cached(cache=TTLCache(maxsize=128, ttl=600))
+    @cached(cache=TTLCache(maxsize=128 if settings.BIG_MEMORY_MODE else 1, ttl=600))
     def browse(self, domain: str) -> List[TorrentInfo]:
         """
         浏览站点首页内容，返回种子清单，TTL缓存10分钟
@@ -73,7 +73,7 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
             return []
         return self.refresh_torrents(site=site)
 
-    @cached(cache=TTLCache(maxsize=128, ttl=300))
+    @cached(cache=TTLCache(maxsize=128 if settings.BIG_MEMORY_MODE else 1, ttl=300))
     def rss(self, domain: str) -> List[TorrentInfo]:
         """
         获取站点RSS内容，返回种子清单，TTL缓存5分钟
@@ -108,7 +108,6 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
                 site_proxy=site.get("proxy"),
                 site_order=site.get("pri"),
                 title=item.get("title"),
-                description=item.get("description"),
                 enclosure=item.get("enclosure"),
                 page_url=item.get("link"),
                 size=item.get("size"),
@@ -130,7 +129,7 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
 
         # 刷新站点
         if not sites:
-            sites = [str(sid) for sid in (self.systemconfig.get(SystemConfigKey.RssSites) or [])]
+            sites = self.systemconfig.get(SystemConfigKey.RssSites) or []
 
         # 读取缓存
         torrents_cache = self.get_torrents()
@@ -140,7 +139,7 @@ class TorrentsChain(ChainBase, metaclass=Singleton):
         # 遍历站点缓存资源
         for indexer in indexers:
             # 未开启的站点不刷新
-            if sites and str(indexer.get("id")) not in sites:
+            if sites and indexer.get("id") not in sites:
                 continue
             domain = StringUtils.get_url_domain(indexer.get("domain"))
             if stype == "spider":

app/chain/transfer.py

@@ -1,3 +1,4 @@
+import glob
 import re
 import shutil
 import threading
@@ -299,7 +300,7 @@ class TransferChain(ChainBase):
                 if not transferinfo:
                     logger.error("文件转移模块运行失败")
                     return False, "文件转移模块运行失败"
-                if not transferinfo.target_path:
+                if not transferinfo.success:
                     # 转移失败
                     logger.warn(f"{file_path.name} 入库失败：{transferinfo.message}")
                     err_msgs.append(f"{file_path.name} {transferinfo.message}")
@@ -489,6 +490,7 @@ class TransferChain(ChainBase):
         src_path = Path(history.src)
         if not src_path.exists():
             return False, f"源目录不存在：{src_path}"
+        dest_path = Path(history.dest) if history.dest else None
         # 查询媒体信息
         mediainfo = self.recognize_media(mtype=mtype, tmdbid=tmdbid)
         if not mediainfo:
@@ -506,6 +508,7 @@ class TransferChain(ChainBase):
         state, errmsg = self.do_transfer(path=src_path,
                                          mediainfo=mediainfo,
                                          download_hash=history.download_hash,
+                                         target=dest_path,
                                          force=True)
         if not state:
             return False, errmsg
@@ -601,8 +604,10 @@ class TransferChain(ChainBase):
         if not path.exists():
             return
         if path.is_file():
-            # 删除文件
-            path.unlink()
+            # 删除文件、nfo、jpg
+            files = glob.glob(f"{Path(path.parent).joinpath(path.stem)}*")
+            for file in files:
+                Path(file).unlink()
             logger.warn(f"文件 {path} 已删除")
             # 需要删除父目录
         elif str(path.parent) == str(path.root):
@@ -615,11 +620,24 @@ class TransferChain(ChainBase):
             # 删除目录
             logger.warn(f"目录 {path} 已删除")
             # 需要删除父目录
-        # 判断父目录是否为空, 为空则删除
-        for parent_path in path.parents:
-            if str(parent_path.parent) != str(path.root):
-                # 父目录非根目录，才删除父目录
-                files = SystemUtils.list_files(parent_path, settings.RMT_MEDIAEXT)
-                if not files:
-                    shutil.rmtree(parent_path)
-                    logger.warn(f"目录 {parent_path} 已删除")
+
+        # 判断当前媒体父路径下是否有媒体文件，如有则无需遍历父级
+        if not SystemUtils.exits_files(path.parent, settings.RMT_MEDIAEXT):
+            # 媒体库二级分类根路径
+            library_root_names = [
+                settings.LIBRARY_MOVIE_NAME or '电影',
+                settings.LIBRARY_TV_NAME or '电视剧',
+                settings.LIBRARY_ANIME_NAME or '动漫',
+            ]
+
+            # 判断父目录是否为空, 为空则删除
+            for parent_path in path.parents:
+                # 遍历父目录到媒体库二级分类根路径
+                if str(parent_path.name) in library_root_names:
+                    break
+                if str(parent_path.parent) != str(path.root):
+                    # 父目录非根目录，才删除父目录
+                    if not SystemUtils.exits_files(parent_path, settings.RMT_MEDIAEXT):
+                        # 当前路径下没有媒体文件则删除
+                        shutil.rmtree(parent_path)
+                        logger.warn(f"目录 {parent_path} 已删除")

app/chain/webhook.py

@@ -4,7 +4,7 @@ from typing import Any
 from app.chain import ChainBase
 from app.schemas import Notification
 from app.schemas.types import EventType, MediaImageType, MediaType, NotificationType
-from app.utils.http import WebUtils
+from app.utils.web import WebUtils
 
 
 class WebhookChain(ChainBase):

app/command.py

@@ -1,11 +1,9 @@
 import traceback
 from threading import Thread, Event
-from typing import Any, Union
+from typing import Any, Union, Dict
 
 from app.chain import ChainBase
-from app.chain.cookiecloud import CookieCloudChain
 from app.chain.download import DownloadChain
-from app.chain.mediaserver import MediaServerChain
 from app.chain.site import SiteChain
 from app.chain.subscribe import SubscribeChain
 from app.chain.system import SystemChain
@@ -15,6 +13,8 @@ from app.core.event import eventmanager, EventManager
 from app.core.plugin import PluginManager
 from app.db import SessionFactory
 from app.log import logger
+from app.scheduler import Scheduler
+from app.schemas import Notification
 from app.schemas.types import EventType, MessageChannel
 from app.utils.object import ObjectUtils
 from app.utils.singleton import Singleton
@@ -49,13 +49,15 @@ class Command(metaclass=Singleton):
         self.pluginmanager = PluginManager()
         # 处理链
         self.chain = CommandChian(self._db)
+        # 定时服务管理
+        self.scheduler = Scheduler()
         # 内置命令
         self._commands = {
             "/cookiecloud": {
-                "func": CookieCloudChain(self._db).remote_sync,
+                "id": "cookiecloud",
+                "type": "scheduler",
                 "description": "同步站点",
-                "category": "站点",
-                "data": {}
+                "category": "站点"
             },
             "/sites": {
                 "func": SiteChain(self._db).remote_list,
@@ -79,10 +81,10 @@ class Command(metaclass=Singleton):
                 "data": {}
             },
             "/mediaserver_sync": {
-                "func": MediaServerChain(self._db).remote_sync,
+                "id": "mediaserver_sync",
+                "type": "scheduler",
                 "description": "同步媒体服务器",
-                "category": "管理",
-                "data": {}
+                "category": "管理"
             },
             "/subscribes": {
                 "func": SubscribeChain(self._db).remote_list,
@@ -91,22 +93,27 @@ class Command(metaclass=Singleton):
                 "data": {}
             },
             "/subscribe_refresh": {
-                "func": SubscribeChain(self._db).remote_refresh,
+                "id": "subscribe_refresh",
+                "type": "scheduler",
                 "description": "刷新订阅",
-                "category": "订阅",
-                "data": {}
+                "category": "订阅"
             },
             "/subscribe_search": {
-                "func": SubscribeChain(self._db).remote_search,
+                "id": "subscribe_search",
+                "type": "scheduler",
                 "description": "搜索订阅",
-                "category": "订阅",
-                "data": {}
+                "category": "订阅"
             },
             "/subscribe_delete": {
                 "func": SubscribeChain(self._db).remote_delete,
                 "description": "删除订阅",
                 "data": {}
             },
+            "/subscribe_tmdb": {
+                "id": "subscribe_tmdb",
+                "type": "scheduler",
+                "description": "订阅元数据更新"
+            },
             "/downloading": {
                 "func": DownloadChain(self._db).remote_downloading,
                 "description": "正在下载",
@@ -114,10 +121,10 @@ class Command(metaclass=Singleton):
                 "data": {}
             },
             "/transfer": {
-                "func": TransferChain(self._db).process,
+                "id": "transfer",
+                "type": "scheduler",
                 "description": "下载文件整理",
-                "category": "管理",
-                "data": {}
+                "category": "管理"
             },
             "/redo": {
                 "func": TransferChain(self._db).remote_transfer,
@@ -175,6 +182,56 @@ class Command(metaclass=Singleton):
                     except Exception as e:
                         logger.error(f"事件处理出错：{str(e)} - {traceback.format_exc()}")
 
+    def __run_command(self, command: Dict[str, any],
+                      data_str: str = "",
+                      channel: MessageChannel = None, userid: Union[str, int] = None):
+        """
+        运行定时服务
+        """
+        if command.get("type") == "scheduler":
+            # 定时服务
+            if userid:
+                self.chain.post_message(
+                    Notification(
+                        channel=channel,
+                        title=f"开始执行 {command.get('description')} ...",
+                        userid=userid
+                    )
+                )
+
+            # 执行定时任务
+            self.scheduler.start(job_id=command.get("id"))
+
+            if userid:
+                self.chain.post_message(
+                    Notification(
+                        channel=channel,
+                        title=f"{command.get('description')} 执行完成",
+                        userid=userid
+                    )
+                )
+        else:
+            # 命令
+            cmd_data = command['data'] if command.get('data') else {}
+            args_num = ObjectUtils.arguments(command['func'])
+            if args_num > 0:
+                if cmd_data:
+                    # 有内置参数直接使用内置参数
+                    data = cmd_data.get("data") or {}
+                    data['channel'] = channel
+                    data['user'] = userid
+                    cmd_data['data'] = data
+                    command['func'](**cmd_data)
+                elif args_num == 2:
+                    # 没有输入参数，只输入渠道和用户ID
+                    command['func'](channel, userid)
+                elif args_num > 2:
+                    # 多个输入参数：用户输入、用户ID
+                    command['func'](data_str, channel, userid)
+            else:
+                # 没有参数
+                command['func']()
+
     def stop(self):
         """
         停止事件处理线程
@@ -216,23 +273,19 @@ class Command(metaclass=Singleton):
         command = self.get(cmd)
         if command:
             try:
-                logger.info(f"用户 {userid} 开始执行：{command.get('description')} ...")
-                cmd_data = command['data'] if command.get('data') else {}
-                args_num = ObjectUtils.arguments(command['func'])
-                if args_num > 0:
-                    if cmd_data:
-                        # 有内置参数直接使用内置参数
-                        command['func'](**cmd_data)
-                    elif args_num == 2:
-                        # 没有输入参数，只输入渠道和用户ID
-                        command['func'](channel, userid)
-                    elif args_num > 2:
-                        # 多个输入参数：用户输入、用户ID
-                        command['func'](data_str, channel, userid)
+                if userid:
+                    logger.info(f"用户 {userid} 开始执行：{command.get('description')} ...")
                 else:
-                    # 没有参数
-                    command['func']()
-                logger.info(f"用户 {userid} {command.get('description')} 执行完成")
+                    logger.info(f"开始执行：{command.get('description')} ...")
+
+                # 执行命令
+                self.__run_command(command, data_str=data_str,
+                                   channel=channel, userid=userid)
+
+                if userid:
+                    logger.info(f"用户 {userid} {command.get('description')} 执行完成")
+                else:
+                    logger.info(f"{command.get('description')} 执行完成")
             except Exception as err:
                 logger.error(f"执行命令 {cmd} 出错：{str(err)}")
                 traceback.print_exc()

app/core/config.py

@@ -72,11 +72,11 @@ class Settings(BaseSettings):
     SUBSCRIBE_RSS_INTERVAL: int = 30
     # 订阅搜索开关
     SUBSCRIBE_SEARCH: bool = False
-    # 用户认证站点 hhclub/audiences/hddolby/zmpt/freefarm/hdfans/wintersakura/leaves/1ptba/icc2022/iyuu
+    # 用户认证站点
     AUTH_SITE: str = ""
     # 交互搜索自动下载用户ID，使用,分割
     AUTO_DOWNLOAD_USER: str = None
-    # 消息通知渠道 telegram/wechat/slack
+    # 消息通知渠道 telegram/wechat/slack，多个通知渠道用,分隔
     MESSAGER: str = "telegram"
     # WeChat企业ID
     WECHAT_CORPID: str = None
@@ -106,6 +106,10 @@ class Settings(BaseSettings):
     SLACK_APP_TOKEN: str = ""
     # Slack 频道名称
     SLACK_CHANNEL: str = ""
+    # SynologyChat Webhook
+    SYNOLOGYCHAT_WEBHOOK: str = ""
+    # SynologyChat Token
+    SYNOLOGYCHAT_TOKEN: str = ""
     # 下载器 qbittorrent/transmission
     DOWNLOADER: str = "qbittorrent"
     # 下载器监控开关
@@ -138,12 +142,14 @@ class Settings(BaseSettings):
     DOWNLOAD_CATEGORY: bool = False
     # 下载站点字幕
     DOWNLOAD_SUBTITLE: bool = True
-    # 媒体服务器 emby/jellyfin/plex
+    # 媒体服务器 emby/jellyfin/plex，多个媒体服务器,分割
     MEDIASERVER: str = "emby"
     # 入库刷新媒体库
     REFRESH_MEDIASERVER: bool = True
     # 媒体服务器同步间隔（小时）
     MEDIASERVER_SYNC_INTERVAL: int = 6
+    # 媒体服务器同步黑名单，多个媒体库名称,分割
+    MEDIASERVER_SYNC_BLACKLIST: str = None
     # EMBY服务器地址，IP:PORT
     EMBY_HOST: str = None
     # EMBY Api Key

app/db/models/__init__.py

@@ -1,4 +1,4 @@
-from typing import Any
+from typing import Any, Self, List
 
 from sqlalchemy.orm import as_declarative, declared_attr, Session
 
@@ -16,13 +16,13 @@ class Base:
             db.rollback()
             raise err
 
-    def create(self, db: Session):
+    def create(self, db: Session) -> Self:
         db.add(self)
         self.commit(db)
         return self
 
     @classmethod
-    def get(cls, db: Session, rid: int):
+    def get(cls, db: Session, rid: int) -> Self:
         return db.query(cls).filter(cls.id == rid).first()
 
     def update(self, db: Session, payload: dict):
@@ -42,7 +42,7 @@ class Base:
         Base.commit(db)
 
     @classmethod
-    def list(cls, db: Session):
+    def list(cls, db: Session) -> List[Self]:
         return db.query(cls).all()
 
     def to_dict(self):

app/helper/cookie.py

@@ -23,14 +23,17 @@ class CookieHelper:
         "password": [
             '//input[@name="password"]',
             '//input[@id="form_item_password"]',
-            '//input[@id="password"]'
+            '//input[@id="password"]',
+            '//input[@type="password"]'
         ],
         "captcha": [
             '//input[@name="imagestring"]',
             '//input[@name="captcha"]',
-            '//input[@id="form_item_captcha"]'
+            '//input[@id="form_item_captcha"]',
+            '//input[@placeholder="驗證碼"]'
         ],
         "captcha_img": [
+            '//img[@alt="captcha"]/@src',
             '//img[@alt="CAPTCHA"]/@src',
             '//img[@alt="SECURITY CODE"]/@src',
             '//img[@id="LAY-user-get-vercode"]/@src',

app/modules/__init__.py

@@ -58,6 +58,8 @@ def checkMessage(channel_type: MessageChannel):
                                 return None
                             if channel_type == MessageChannel.Slack and not switch.get("slack"):
                                 return None
+                            if channel_type == MessageChannel.SynologyChat and not switch.get("synologychat"):
+                                return None
                 return func(self, message, *args, **kwargs)
 
         return wrapper

app/modules/emby/__init__.py

@@ -1,4 +1,3 @@
-import json
 from pathlib import Path
 from typing import Optional, Tuple, Union, Any, List, Generator
 
@@ -41,7 +40,7 @@ class EmbyModule(_ModuleBase):
         # Emby认证
         return self.emby.authenticate(name, password)
 
-    def webhook_parser(self, body: Any, form: Any, args: Any) -> WebhookEventInfo:
+    def webhook_parser(self, body: Any, form: Any, args: Any) -> Optional[WebhookEventInfo]:
         """
         解析Webhook报文体
         :param body:  请求体
@@ -49,11 +48,7 @@ class EmbyModule(_ModuleBase):
         :param args:  请求参数
         :return: 字典，解析为消息时需要包含：title、text、image
         """
-        if form and form.get("data"):
-            result = form.get("data")
-        else:
-            result = json.dumps(dict(args))
-        return self.emby.get_webhook_message(result)
+        return self.emby.get_webhook_message(form, args)
 
     def media_exists(self, mediainfo: MediaInfo, itemid: str = None) -> Optional[ExistMediaInfo]:
         """
@@ -87,7 +82,7 @@ class EmbyModule(_ModuleBase):
                 logger.info(f"{mediainfo.title_year} 媒体库中已存在：{tvs}")
                 return ExistMediaInfo(type=MediaType.TV, seasons=tvs)
 
-    def refresh_mediaserver(self, mediainfo: MediaInfo, file_path: Path) -> Optional[bool]:
+    def refresh_mediaserver(self, mediainfo: MediaInfo, file_path: Path) -> None:
         """
         刷新媒体库
         :param mediainfo:  识别的媒体信息
@@ -103,25 +98,27 @@ class EmbyModule(_ModuleBase):
                 target_path=file_path
             )
         ]
-        return self.emby.refresh_library_by_items(items)
+        self.emby.refresh_library_by_items(items)
 
-    def media_statistic(self) -> schemas.Statistic:
+    def media_statistic(self) -> List[schemas.Statistic]:
         """
         媒体数量统计
         """
         media_statistic = self.emby.get_medias_count()
         user_count = self.emby.get_user_count()
-        return schemas.Statistic(
+        return [schemas.Statistic(
             movie_count=media_statistic.get("MovieCount") or 0,
             tv_count=media_statistic.get("SeriesCount") or 0,
             episode_count=media_statistic.get("EpisodeCount") or 0,
             user_count=user_count or 0
-        )
+        )]
 
-    def mediaserver_librarys(self) -> List[schemas.MediaServerLibrary]:
+    def mediaserver_librarys(self, server: str) -> Optional[List[schemas.MediaServerLibrary]]:
         """
         媒体库列表
         """
+        if server != "emby":
+            return None
         librarys = self.emby.get_librarys()
         if not librarys:
             return []
@@ -133,10 +130,12 @@ class EmbyModule(_ModuleBase):
             path=library.get("path")
         ) for library in librarys]
 
-    def mediaserver_items(self, library_id: str) -> Generator:
+    def mediaserver_items(self, server: str, library_id: str) -> Optional[Generator]:
         """
         媒体库项目列表
         """
+        if server != "emby":
+            return None
         items = self.emby.get_items(library_id)
         for item in items:
             yield schemas.MediaServerItem(
@@ -153,10 +152,13 @@ class EmbyModule(_ModuleBase):
                 path=item.get("path"),
             )
 
-    def mediaserver_tv_episodes(self, item_id: Union[str, int]) -> List[schemas.MediaServerSeasonInfo]:
+    def mediaserver_tv_episodes(self, server: str,
+                                item_id: Union[str, int]) -> Optional[List[schemas.MediaServerSeasonInfo]]:
         """
         获取剧集信息
         """
+        if server != "emby":
+            return None
         seasoninfo = self.emby.get_tv_episodes(item_id=item_id)
         if not seasoninfo:
             return []

app/modules/emby/emby.py

@@ -272,8 +272,8 @@ class Emby(metaclass=Singleton):
             return None
         return ""
 
-    def get_movies(self, 
-                   title: str, 
+    def get_movies(self,
+                   title: str,
                    year: str = None,
                    tmdb_id: int = None) -> Optional[List[dict]]:
         """
@@ -338,10 +338,12 @@ class Emby(metaclass=Singleton):
             if not item_id:
                 return {}
         # 验证tmdbid是否相同
-        item_tmdbid = (self.get_iteminfo(item_id).get("ProviderIds") or {}).get("Tmdb")
-        if tmdb_id and item_tmdbid:
-            if str(tmdb_id) != str(item_tmdbid):
-                return {}
+        item_info = self.get_iteminfo(item_id)
+        if item_info:
+            item_tmdbid = (item_info.get("ProviderIds") or {}).get("Tmdb")
+            if tmdb_id and item_tmdbid:
+                if str(tmdb_id) != str(item_tmdbid):
+                    return {}
         # /Shows/Id/Episodes 查集的信息
         if not season:
             season = ""
@@ -543,7 +545,7 @@ class Emby(metaclass=Singleton):
             logger.error(f"连接Users/Items出错：" + str(e))
         yield {}
 
-    def get_webhook_message(self, message_str: str) -> WebhookEventInfo:
+    def get_webhook_message(self, form: any, args: dict) -> Optional[WebhookEventInfo]:
         """
         解析Emby Webhook报文
         电影：
@@ -781,9 +783,22 @@ class Emby(metaclass=Singleton):
           }
         }
         """
-        message = json.loads(message_str)
+        if not form and not args:
+            return None
+        try:
+            if form and form.get("data"):
+                result = form.get("data")
+            else:
+                result = json.dumps(dict(args))
+            message = json.loads(result)
+        except Exception as e:
+            logger.debug(f"解析emby webhook报文出错：" + str(e))
+            return None
+        eventType = message.get('Event')
+        if not eventType:
+            return None
         logger.info(f"接收到emby webhook：{message}")
-        eventItem = WebhookEventInfo(event=message.get('Event', ''), channel="emby")
+        eventItem = WebhookEventInfo(event=eventType, channel="emby")
         if message.get('Item'):
             if message.get('Item', {}).get('Type') == 'Episode':
                 eventItem.item_type = "TV"

app/modules/filetransfer/__init__.py

@@ -43,9 +43,13 @@ class FileTransferModule(_ModuleBase):
         # 获取目标路径
         if not target:
             target = self.get_target_path(in_path=path)
+        else:
+            target = self.get_library_path(target)
         if not target:
             logger.error("未找到媒体库目录，无法转移文件")
-            return TransferInfo(message="未找到媒体库目录，无法转移文件")
+            return TransferInfo(success=False,
+                                path=path,
+                                message="未找到媒体库目录，无法转移文件")
         # 转移
         return self.transfer_media(in_path=path,
                                    in_meta=meta,
@@ -316,9 +320,11 @@ class FileTransferModule(_ModuleBase):
                                            over_flag=over_flag)
 
     @staticmethod
-    def __get_library_dir(mediainfo: MediaInfo, target_dir: Path) -> Path:
+    def __get_dest_dir(mediainfo: MediaInfo, target_dir: Path) -> Path:
         """
         根据设置并装媒体库目录
+        :param mediainfo: 媒体信息
+        :target_dir: 媒体库根目录
         """
         if mediainfo.type == MediaType.MOVIE:
             # 电影
@@ -355,19 +361,23 @@ class FileTransferModule(_ModuleBase):
         :param in_path: 转移的路径，可能是一个文件也可以是一个目录
         :param in_meta：预识别元数据
         :param mediainfo: 媒体信息
-        :param target_dir: 目的文件夹，非空的转移到该文件夹，为空时则按类型转移到配置文件中的媒体库文件夹
+        :param target_dir: 媒体库根目录
         :param transfer_type: 文件转移方式
         :return: TransferInfo、错误信息
         """
         # 检查目录路径
         if not in_path.exists():
-            return TransferInfo(message=f"{in_path} 路径不存在")
+            return TransferInfo(success=False,
+                                path=in_path,
+                                message=f"{in_path} 路径不存在")
 
         if not target_dir.exists():
-            return TransferInfo(message=f"{target_dir} 目标路径不存在")
+            return TransferInfo(success=False,
+                                path=in_path,
+                                message=f"{target_dir} 目标路径不存在")
 
-        # 媒体库目录
-        target_dir = self.__get_library_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 \
@@ -393,11 +403,16 @@ class FileTransferModule(_ModuleBase):
                                           transfer_type=transfer_type)
             if retcode != 0:
                 logger.error(f"文件夹 {in_path} 转移失败，错误码：{retcode}")
-                return TransferInfo(message=f"文件夹 {in_path} 转移失败，错误码：{retcode}")
+                return TransferInfo(success=False,
+                                    message=f"文件夹 {in_path} 转移失败，错误码：{retcode}",
+                                    path=in_path,
+                                    target_path=new_path,
+                                    is_bluray=bluray_flag)
 
             logger.info(f"文件夹 {in_path} 转移成功")
             # 返回转移后的路径
-            return TransferInfo(path=in_path,
+            return TransferInfo(success=True,
+                                path=in_path,
                                 target_path=new_path,
                                 total_size=new_path.stat().st_size,
                                 is_bluray=bluray_flag)
@@ -440,11 +455,15 @@ class FileTransferModule(_ModuleBase):
                                            over_flag=overflag)
             if retcode != 0:
                 logger.error(f"文件 {in_path} 转移失败，错误码：{retcode}")
-                return TransferInfo(message=f"文件 {in_path.name} 转移失败，错误码：{retcode}",
+                return TransferInfo(success=False,
+                                    message=f"文件 {in_path.name} 转移失败，错误码：{retcode}",
+                                    path=in_path,
+                                    target_path=new_file,
                                     fail_list=[str(in_path)])
 
             logger.info(f"文件 {in_path} 转移成功")
-            return TransferInfo(path=in_path,
+            return TransferInfo(success=True,
+                                path=in_path,
                                 target_path=new_file,
                                 file_count=1,
                                 total_size=new_file.stat().st_size,
@@ -514,6 +533,26 @@ class FileTransferModule(_ModuleBase):
         else:
             return Path(render_str)
 
+    @staticmethod
+    def get_library_path(path: Path):
+        """
+        根据目录查询其所在的媒体库目录，查询不到的返回输入目录
+        """
+        if not path:
+            return None
+        if not settings.LIBRARY_PATHS:
+            return path
+        # 目的路径，多路径以,分隔
+        dest_paths = settings.LIBRARY_PATHS
+        for libpath in dest_paths:
+            try:
+                if path.is_relative_to(libpath):
+                    return libpath
+            except Exception as e:
+                logger.debug(f"计算媒体库路径时出错：{e}")
+                continue
+        return path
+
     @staticmethod
     def get_target_path(in_path: Path = None) -> Optional[Path]:
         """
@@ -533,7 +572,7 @@ class FileTransferModule(_ModuleBase):
         if in_path:
             for path in dest_paths:
                 try:
-                    relative = Path(in_path).relative_to(path).as_posix()
+                    relative = in_path.relative_to(path).as_posix()
                     if len(relative) > max_length:
                         max_length = len(relative)
                         target_path = path
@@ -569,7 +608,7 @@ class FileTransferModule(_ModuleBase):
             if not target_dir:
                 continue
             # 媒体分类路径
-            target_dir = self.__get_library_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 \
                 if mediainfo.type == MediaType.TV else settings.MOVIE_RENAME_FORMAT

app/modules/filter/__init__.py

@@ -1,7 +1,7 @@
 import re
 from typing import List, Tuple, Union, Dict, Optional
 
-from app.core.context import TorrentInfo
+from app.core.context import TorrentInfo, MediaInfo
 from app.core.metainfo import MetaInfo
 from app.log import logger
 from app.modules import _ModuleBase
@@ -9,9 +9,10 @@ from app.modules.filter.RuleParser import RuleParser
 
 
 class FilterModule(_ModuleBase):
-
     # 规则解析器
     parser: RuleParser = None
+    # 媒体信息
+    media: MediaInfo = None
 
     # 内置规则集
     rule_set: Dict[str, dict] = {
@@ -37,8 +38,12 @@ class FilterModule(_ModuleBase):
         },
         # 中字
         "CNSUB": {
-            "include": [r'[中国國繁简](/|\s|\\|\|)?[繁简英粤]|[英简繁](/|\s|\\|\|)?[中繁简]|繁體|简体|[中国國][字配]|国语|國語|中文|中字'],
-            "exclude": []
+            "include": [
+                r'[中国國繁简](/|\s|\\|\|)?[繁简英粤]|[英简繁](/|\s|\\|\|)?[中繁简]|繁體|简体|[中国國][字配]|国语|國語|中文|中字'],
+            "exclude": [],
+            "tmdb": {
+                "original_language": "zh,cn"
+            }
         },
         # 特效字幕
         "SPECSUB": {
@@ -107,16 +112,19 @@ class FilterModule(_ModuleBase):
 
     def filter_torrents(self, rule_string: str,
                         torrent_list: List[TorrentInfo],
-                        season_episodes: Dict[int, list] = None) -> List[TorrentInfo]:
+                        season_episodes: Dict[int, list] = None,
+                        mediainfo: MediaInfo = None) -> List[TorrentInfo]:
         """
         过滤种子资源
         :param rule_string:  过滤规则
         :param torrent_list:  资源列表
         :param season_episodes:  季集数过滤 {season:[episodes]}
+        :param mediainfo:  媒体信息
         :return: 过滤后的资源列表，添加资源优先级
         """
         if not rule_string:
             return torrent_list
+        self.media = mediainfo
         # 返回种子列表
         ret_torrents = []
         for torrent in torrent_list:
@@ -215,6 +223,11 @@ class FilterModule(_ModuleBase):
         if not self.rule_set.get(rule_name):
             # 规则不存在
             return False
+        # TMDB规则
+        tmdb = self.rule_set[rule_name].get("tmdb")
+        # 符合TMDB规则的直接返回True，即不过滤
+        if tmdb and self.__match_tmdb(tmdb):
+            return True
         # 包含规则项
         includes = self.rule_set[rule_name].get("include") or []
         # 排除规则项
@@ -236,3 +249,44 @@ class FilterModule(_ModuleBase):
                 # FREE规则不匹配
                 return False
         return True
+
+    def __match_tmdb(self, tmdb: dict) -> bool:
+        """
+        判断种子是否匹配TMDB规则
+        """
+        def __get_media_value(key: str):
+            try:
+                return getattr(self.media, key)
+            except ValueError:
+                return ""
+
+        if not self.media:
+            return False
+
+        for attr, value in tmdb.items():
+            if not value:
+                continue
+            # 获取media信息的值
+            info_value = __get_media_value(attr)
+            if not info_value:
+                # 没有该值，不匹配
+                return False
+            elif attr == "production_countries":
+                # 国家信息
+                info_values = [str(val.get("iso_3166_1")).upper() for val in info_value]
+            else:
+                # media信息转化为数组
+                if isinstance(info_value, list):
+                    info_values = [str(val).upper() for val in info_value]
+                else:
+                    info_values = [str(info_value).upper()]
+            # 过滤值转化为数组
+            if value.find(",") != -1:
+                values = [str(val).upper() for val in value.split(",")]
+            else:
+                values = [str(value).upper()]
+            # 没有交集为不匹配
+            if not set(values).intersection(set(info_values)):
+                return False
+
+        return True

app/modules/indexer/__init__.py

@@ -6,6 +6,7 @@ from ruamel.yaml import CommentedMap
 from app.core.context import MediaInfo, TorrentInfo
 from app.log import logger
 from app.modules import _ModuleBase
+from app.modules.indexer.mtorrent import MTorrentSpider
 from app.modules.indexer.spider import TorrentSpider
 from app.modules.indexer.tnode import TNodeSpider
 from app.modules.indexer.torrentleech import TorrentLeech
@@ -74,6 +75,12 @@ class IndexerModule(_ModuleBase):
                     keyword=search_word,
                     page=page
                 )
+            elif site.get('parser') == "mTorrent":
+                error_flag, result_array = MTorrentSpider(site).search(
+                    keyword=search_word,
+                    mtype=mediainfo.type if mediainfo else None,
+                    page=page
+                )
             else:
                 error_flag, result_array = self.__spider_search(
                     keyword=search_word,

app/modules/indexer/mtorrent.py

@@ -0,0 +1,144 @@
+import base64
+import json
+import re
+from typing import Tuple, List
+
+from ruamel.yaml import CommentedMap
+
+from app.core.config import settings
+from app.log import logger
+from app.schemas import MediaType
+from app.utils.http import RequestUtils
+from app.utils.string import StringUtils
+
+
+class MTorrentSpider:
+    _indexerid = None
+    _domain = None
+    _name = ""
+    _proxy = None
+    _cookie = None
+    _ua = None
+    _size = 100
+    _searchurl = "%sapi/torrent/search"
+    _downloadurl = "%sapi/torrent/genDlToken"
+    _pageurl = "%sdetail/%s"
+
+    # 电影分类
+    _movie_category = ['401', '419', '420', '421', '439', '405', '404']
+    _tv_category = ['403', '402', '435', '438', '404', '405']
+
+    # 标签
+    _labels = {
+        0: "",
+        4: "中字",
+        6: "国配",
+    }
+
+    def __init__(self, indexer: CommentedMap):
+        if indexer:
+            self._indexerid = indexer.get('id')
+            self._domain = indexer.get('domain')
+            self._searchurl = self._searchurl % self._domain
+            self._name = indexer.get('name')
+            if indexer.get('proxy'):
+                self._proxy = settings.PROXY
+            self._cookie = indexer.get('cookie')
+            self._ua = indexer.get('ua')
+
+    def search(self, keyword: str, mtype: MediaType = None, page: int = 0) -> Tuple[bool, List[dict]]:
+        if not mtype:
+            categories = []
+        elif mtype == MediaType.TV:
+            categories = self._tv_category
+        else:
+            categories = self._movie_category
+        params = {
+            "keyword": keyword,
+            "categories": categories,
+            "pageNumber": int(page) + 1,
+            "pageSize": self._size,
+            "visible": 1
+        }
+        res = RequestUtils(
+            headers={
+                "Content-Type": "application/json",
+                "User-Agent": f"{self._ua}"
+            },
+            cookies=self._cookie,
+            proxies=self._proxy,
+            referer=f"{self._domain}browse",
+            timeout=30
+        ).post_res(url=self._searchurl, json=params)
+        torrents = []
+        if res and res.status_code == 200:
+            results = res.json().get('data', {}).get("data") or []
+            for result in results:
+                torrent = {
+                    'title': result.get('name'),
+                    'description': result.get('smallDescr'),
+                    'enclosure': self.__get_download_url(result.get('id')),
+                    'pubdate': StringUtils.format_timestamp(result.get('createdDate')),
+                    'size': result.get('size'),
+                    'seeders': result.get('status', {}).get("seeders"),
+                    'peers': result.get('status', {}).get("leechers"),
+                    'grabs': result.get('status', {}).get("timesCompleted"),
+                    'downloadvolumefactor': self.__get_downloadvolumefactor(result.get('status', {}).get("discount")),
+                    'uploadvolumefactor': self.__get_uploadvolumefactor(result.get('status', {}).get("discount")),
+                    'page_url': self._pageurl % (self._domain, result.get('id')),
+                    'imdbid': self.__find_imdbid(result.get('imdb')),
+                    'labels': [self._labels.get(result.get('labels') or 0)] if result.get('labels') else []
+                }
+                torrents.append(torrent)
+        elif res is not None:
+            logger.warn(f"{self._name} 搜索失败，错误码：{res.status_code}")
+            return True, []
+        else:
+            logger.warn(f"{self._name} 搜索失败，无法连接 {self._domain}")
+            return True, []
+        return False, torrents
+
+    @staticmethod
+    def __find_imdbid(imdb: str) -> str:
+        if imdb:
+            m = re.search(r"tt\d+", imdb)
+            if m:
+                return m.group(0)
+        return ""
+
+    @staticmethod
+    def __get_downloadvolumefactor(discount: str) -> float:
+        discount_dict = {
+            "FREE": 0,
+            "PERCENT_50": 0.5,
+            "PERCENT_70": 0.3,
+            "_2X_FREE": 0,
+            "_2X_PERCENT_50": 0.5
+        }
+        if discount:
+            return discount_dict.get(discount, 1)
+        return 1
+
+    @staticmethod
+    def __get_uploadvolumefactor(discount: str) -> float:
+        uploadvolumefactor_dict = {
+            "_2X": 2.0,
+            "_2X_FREE": 2.0,
+            "_2X_PERCENT_50": 2.0
+        }
+        if discount:
+            return uploadvolumefactor_dict.get(discount, 1)
+        return 1
+
+    def __get_download_url(self, torrent_id: str) -> str:
+        url = self._downloadurl % self._domain
+        params = {
+            'method': 'post',
+            'params': {
+                'id': torrent_id
+            },
+            'result': 'data'
+        }
+        # base64编码
+        base64_str = base64.b64encode(json.dumps(params).encode('utf-8')).decode('utf-8')
+        return f"[{base64_str}]{url}"

app/modules/jellyfin/__init__.py

@@ -41,7 +41,7 @@ class JellyfinModule(_ModuleBase):
         # Jellyfin认证
         return self.jellyfin.authenticate(name, password)
 
-    def webhook_parser(self, body: Any, form: Any, args: Any) -> WebhookEventInfo:
+    def webhook_parser(self, body: Any, form: Any, args: Any) -> Optional[WebhookEventInfo]:
         """
         解析Webhook报文体
         :param body:  请求体
@@ -49,7 +49,7 @@ class JellyfinModule(_ModuleBase):
         :param args:  请求参数
         :return: 字典，解析为消息时需要包含：title、text、image
         """
-        return self.jellyfin.get_webhook_message(json.loads(body))
+        return self.jellyfin.get_webhook_message(body)
 
     def media_exists(self, mediainfo: MediaInfo, itemid: str = None) -> Optional[ExistMediaInfo]:
         """
@@ -83,32 +83,34 @@ class JellyfinModule(_ModuleBase):
                 logger.info(f"{mediainfo.title_year} 媒体库中已存在：{tvs}")
                 return ExistMediaInfo(type=MediaType.TV, seasons=tvs)
 
-    def refresh_mediaserver(self, mediainfo: MediaInfo, file_path: Path) -> Optional[bool]:
+    def refresh_mediaserver(self, mediainfo: MediaInfo, file_path: Path) -> None:
         """
         刷新媒体库
         :param mediainfo:  识别的媒体信息
         :param file_path:  文件路径
         :return: 成功或失败
         """
-        return self.jellyfin.refresh_root_library()
+        self.jellyfin.refresh_root_library()
 
-    def media_statistic(self) -> schemas.Statistic:
+    def media_statistic(self) -> List[schemas.Statistic]:
         """
         媒体数量统计
         """
         media_statistic = self.jellyfin.get_medias_count()
         user_count = self.jellyfin.get_user_count()
-        return schemas.Statistic(
+        return [schemas.Statistic(
             movie_count=media_statistic.get("MovieCount") or 0,
             tv_count=media_statistic.get("SeriesCount") or 0,
             episode_count=media_statistic.get("EpisodeCount") or 0,
             user_count=user_count or 0
-        )
+        )]
 
-    def mediaserver_librarys(self) -> List[schemas.MediaServerLibrary]:
+    def mediaserver_librarys(self, server: str) -> Optional[List[schemas.MediaServerLibrary]]:
         """
         媒体库列表
         """
+        if server != "jellyfin":
+            return None
         librarys = self.jellyfin.get_librarys()
         if not librarys:
             return []
@@ -120,10 +122,12 @@ class JellyfinModule(_ModuleBase):
             path=library.get("path")
         ) for library in librarys]
 
-    def mediaserver_items(self, library_id: str) -> Generator:
+    def mediaserver_items(self, server: str, library_id: str) -> Optional[Generator]:
         """
         媒体库项目列表
         """
+        if server != "jellyfin":
+            return None
         items = self.jellyfin.get_items(library_id)
         for item in items:
             yield schemas.MediaServerItem(
@@ -140,10 +144,13 @@ class JellyfinModule(_ModuleBase):
                 path=item.get("path"),
             )
 
-    def mediaserver_tv_episodes(self, item_id: Union[str, int]) -> List[schemas.MediaServerSeasonInfo]:
+    def mediaserver_tv_episodes(self, server: str,
+                                item_id: Union[str, int]) -> Optional[List[schemas.MediaServerSeasonInfo]]:
         """
         获取剧集信息
         """
+        if server != "jellyfin":
+            return None
         seasoninfo = self.jellyfin.get_tv_episodes(item_id=item_id)
         if not seasoninfo:
             return []

app/modules/jellyfin/jellyfin.py

@@ -387,7 +387,7 @@ class Jellyfin(metaclass=Singleton):
             logger.error(f"连接Library/Refresh出错：" + str(e))
             return False
 
-    def get_webhook_message(self, message: dict) -> WebhookEventInfo:
+    def get_webhook_message(self, body: any) -> Optional[WebhookEventInfo]:
         """
         解析Jellyfin报文
         {
@@ -450,9 +450,21 @@ class Jellyfin(metaclass=Singleton):
           "UserId": "9783d2432b0d40a8a716b6aa46xxxxx"
         }
         """
+        if not body:
+            return None
+        try:
+            message = json.loads(body)
+        except Exception as e:
+            logger.debug(f"解析Jellyfin Webhook报文出错：" + str(e))
+            return None
+        if not message:
+            return None
         logger.info(f"接收到jellyfin webhook：{message}")
+        eventType = message.get('NotificationType')
+        if not eventType:
+            return None
         eventItem = WebhookEventInfo(
-            event=message.get('NotificationType', ''),
+            event=eventType,
             channel="jellyfin"
         )
         eventItem.item_id = message.get('ItemId')

app/modules/plex/__init__.py

@@ -31,7 +31,7 @@ class PlexModule(_ModuleBase):
         if not self.plex.is_inactive():
             self.plex = Plex()
 
-    def webhook_parser(self, body: Any, form: Any, args: Any) -> WebhookEventInfo:
+    def webhook_parser(self, body: Any, form: Any, args: Any) -> Optional[WebhookEventInfo]:
         """
         解析Webhook报文体
         :param body:  请求体
@@ -39,7 +39,7 @@ class PlexModule(_ModuleBase):
         :param args:  请求参数
         :return: 字典，解析为消息时需要包含：title、text、image
         """
-        return self.plex.get_webhook_message(form.get("payload"))
+        return self.plex.get_webhook_message(form)
 
     def media_exists(self, mediainfo: MediaInfo, itemid: str = None) -> Optional[ExistMediaInfo]:
         """
@@ -54,7 +54,10 @@ class PlexModule(_ModuleBase):
                 if movie:
                     logger.info(f"媒体库中已存在：{movie}")
                     return ExistMediaInfo(type=MediaType.MOVIE)
-            movies = self.plex.get_movies(title=mediainfo.title, year=mediainfo.year, tmdb_id=mediainfo.tmdb_id)
+            movies = self.plex.get_movies(title=mediainfo.title,
+                                          original_title=mediainfo.original_title, 
+                                          year=mediainfo.year, 
+                                          tmdb_id=mediainfo.tmdb_id)
             if not movies:
                 logger.info(f"{mediainfo.title_year} 在媒体库中不存在")
                 return None
@@ -63,6 +66,7 @@ class PlexModule(_ModuleBase):
                 return ExistMediaInfo(type=MediaType.MOVIE)
         else:
             tvs = self.plex.get_tv_episodes(title=mediainfo.title,
+                                            original_title=mediainfo.original_title,
                                             year=mediainfo.year,
                                             tmdb_id=mediainfo.tmdb_id,
                                             item_id=itemid)
@@ -73,7 +77,7 @@ class PlexModule(_ModuleBase):
                 logger.info(f"{mediainfo.title_year} 媒体库中已存在：{tvs}")
                 return ExistMediaInfo(type=MediaType.TV, seasons=tvs)
 
-    def refresh_mediaserver(self, mediainfo: MediaInfo, file_path: Path) -> Optional[bool]:
+    def refresh_mediaserver(self, mediainfo: MediaInfo, file_path: Path) -> None:
         """
         刷新媒体库
         :param mediainfo:  识别的媒体信息
@@ -89,24 +93,26 @@ class PlexModule(_ModuleBase):
                 target_path=file_path
             )
         ]
-        return self.plex.refresh_library_by_items(items)
+        self.plex.refresh_library_by_items(items)
 
-    def media_statistic(self) -> schemas.Statistic:
+    def media_statistic(self) -> List[schemas.Statistic]:
         """
         媒体数量统计
         """
         media_statistic = self.plex.get_medias_count()
-        return schemas.Statistic(
+        return [schemas.Statistic(
             movie_count=media_statistic.get("MovieCount") or 0,
             tv_count=media_statistic.get("SeriesCount") or 0,
             episode_count=media_statistic.get("EpisodeCount") or 0,
             user_count=1
-        )
+        )]
 
-    def mediaserver_librarys(self) -> List[schemas.MediaServerLibrary]:
+    def mediaserver_librarys(self, server: str) -> Optional[List[schemas.MediaServerLibrary]]:
         """
         媒体库列表
         """
+        if server != "plex":
+            return None
         librarys = self.plex.get_librarys()
         if not librarys:
             return []
@@ -118,10 +124,12 @@ class PlexModule(_ModuleBase):
             path=library.get("path")
         ) for library in librarys]
 
-    def mediaserver_items(self, library_id: str) -> Generator:
+    def mediaserver_items(self, server: str, library_id: str) -> Optional[Generator]:
         """
         媒体库项目列表
         """
+        if server != "plex":
+            return None
         items = self.plex.get_items(library_id)
         for item in items:
             yield schemas.MediaServerItem(
@@ -138,10 +146,13 @@ class PlexModule(_ModuleBase):
                 path=item.get("path"),
             )
 
-    def mediaserver_tv_episodes(self, item_id: Union[str, int]) -> List[schemas.MediaServerSeasonInfo]:
+    def mediaserver_tv_episodes(self, server: str,
+                                item_id: Union[str, int]) -> Optional[List[schemas.MediaServerSeasonInfo]]:
         """
         获取剧集信息
         """
+        if server != "plex":
+            return None
         seasoninfo = self.plex.get_tv_episodes(item_id=item_id)
         if not seasoninfo:
             return []

app/modules/plex/plex.py

@@ -130,11 +130,13 @@ class Plex(metaclass=Singleton):
 
     def get_movies(self, 
                    title: str, 
+                   original_title: str = None,
                    year: str = None,
                    tmdb_id: int = None) -> Optional[List[dict]]:
         """
         根据标题和年份，检查电影是否在Plex中存在，存在则返回列表
         :param title: 标题
+        :param original_title: 原产地标题
         :param year: 年份，为空则不过滤
         :param tmdb_id: TMDB ID
         :return: 含title、year属性的字典列表
@@ -144,9 +146,14 @@ class Plex(metaclass=Singleton):
         ret_movies = []
         if year:
             movies = self._plex.library.search(title=title, year=year, libtype="movie")
+            # 根据原标题再查一遍
+            if original_title and str(original_title) != str(title):
+                movies.extend(self._plex.library.search(title=original_title, year=year, libtype="movie"))
         else:
             movies = self._plex.library.search(title=title, libtype="movie")
-        for movie in movies:
+            if original_title and str(original_title) != str(title):
+                movies.extend(self._plex.library.search(title=original_title, year=year, libtype="movie"))
+        for movie in set(movies):
             movie_tmdbid = self.__get_ids(movie.guids).get("tmdb_id")
             if tmdb_id and movie_tmdbid:
                 if str(movie_tmdbid) != str(tmdb_id):
@@ -157,6 +164,7 @@ class Plex(metaclass=Singleton):
     def get_tv_episodes(self,
                         item_id: str = None,
                         title: str = None,
+                        original_title: str = None,
                         year: str = None,
                         tmdb_id: int = None,
                         season: int = None) -> Optional[Dict[int, list]]:
@@ -164,6 +172,7 @@ class Plex(metaclass=Singleton):
         根据标题、年份、季查询电视剧所有集信息
         :param item_id: 媒体ID
         :param title: 标题
+        :param original_title: 原产地标题
         :param year: 年份，可以为空，为空时不按年份过滤
         :param tmdb_id: TMDB ID
         :param season: 季号，数字
@@ -176,6 +185,8 @@ class Plex(metaclass=Singleton):
         else:
             # 根据标题和年份模糊搜索，该结果不够准确
             videos = self._plex.library.search(title=title, year=year, libtype="show")
+            if not videos and original_title and str(original_title) != str(title):
+                videos = self._plex.library.search(title=original_title, year=year, libtype="show")
         if not videos:
             return {}
         if isinstance(videos, list):
@@ -267,7 +278,7 @@ class Plex(metaclass=Singleton):
                 if hasattr(lib, "locations") and lib.locations:
                     for location in lib.locations:
                         if is_subpath(path, Path(location)):
-                            return lib.key, location
+                            return lib.key, str(path)
         except Exception as err:
             logger.error(f"查找媒体库出错：{err}")
         return "", ""
@@ -342,7 +353,7 @@ class Plex(metaclass=Singleton):
             logger.error(f"获取媒体库列表出错：{err}")
         yield {}
 
-    def get_webhook_message(self, message_str: str) -> WebhookEventInfo:
+    def get_webhook_message(self, form: any) -> Optional[WebhookEventInfo]:
         """
         解析Plex报文
         eventItem  字段的含义
@@ -446,9 +457,21 @@ class Plex(metaclass=Singleton):
           }
         }
         """
-        message = json.loads(message_str)
+        if not form:
+            return None
+        payload = form.get("payload")
+        if not payload:
+            return None
+        try:
+            message = json.loads(payload)
+        except Exception as e:
+            logger.debug(f"解析plex webhook出错：{str(e)}")
+            return None
+        eventType = message.get('event')
+        if not eventType:
+            return None
         logger.info(f"接收到plex webhook：{message}")
-        eventItem = WebhookEventInfo(event=message.get('event', ''), channel="plex")
+        eventItem = WebhookEventInfo(event=eventType, channel="plex")
         if message.get('Metadata'):
             if message.get('Metadata', {}).get('type') == 'episode':
                 eventItem.item_type = "TV"

app/modules/synologychat/__init__.py

@@ -0,0 +1,85 @@
+from typing import Optional, Union, List, Tuple, Any
+
+from app.core.context import MediaInfo, Context
+from app.log import logger
+from app.modules import _ModuleBase, checkMessage
+from app.modules.synologychat.synologychat import SynologyChat
+from app.schemas import MessageChannel, CommingMessage, Notification
+
+
+class SynologyChatModule(_ModuleBase):
+    synologychat: SynologyChat = None
+
+    def init_module(self) -> None:
+        self.synologychat = SynologyChat()
+
+    def stop(self):
+        pass
+
+    def init_setting(self) -> Tuple[str, Union[str, bool]]:
+        return "MESSAGER", "synologychat"
+
+    def message_parser(self, body: Any, form: Any,
+                       args: Any) -> Optional[CommingMessage]:
+        """
+        解析消息内容，返回字典，注意以下约定值：
+        userid: 用户ID
+        username: 用户名
+        text: 内容
+        :param body: 请求体
+        :param form: 表单
+        :param args: 参数
+        :return: 渠道、消息体
+        """
+        try:
+            message: dict = form
+            if not message:
+                return None
+            # 校验token
+            token = message.get("token")
+            if not token or not self.synologychat.check_token(token):
+                return None
+            # 文本
+            text = message.get("text")
+            # 用户ID
+            user_id = int(message.get("user_id"))
+            # 获取用户名
+            user_name = message.get("username")
+            if text and user_id:
+                logger.info(f"收到SynologyChat消息：userid={user_id}, username={user_name}, text={text}")
+                return CommingMessage(channel=MessageChannel.SynologyChat,
+                                      userid=user_id, username=user_name, text=text)
+        except Exception as err:
+            logger.debug(f"解析SynologyChat消息失败：{err}")
+        return None
+
+    @checkMessage(MessageChannel.SynologyChat)
+    def post_message(self, message: Notification) -> None:
+        """
+        发送消息
+        :param message: 消息体
+        :return: 成功或失败
+        """
+        self.synologychat.send_msg(title=message.title, text=message.text,
+                                   image=message.image, userid=message.userid)
+
+    @checkMessage(MessageChannel.SynologyChat)
+    def post_medias_message(self, message: Notification, medias: List[MediaInfo]) -> Optional[bool]:
+        """
+        发送媒体信息选择列表
+        :param message: 消息体
+        :param medias: 媒体列表
+        :return: 成功或失败
+        """
+        return self.synologychat.send_meidas_msg(title=message.title, medias=medias,
+                                                 userid=message.userid)
+
+    @checkMessage(MessageChannel.SynologyChat)
+    def post_torrents_message(self, message: Notification, torrents: List[Context]) -> Optional[bool]:
+        """
+        发送种子信息选择列表
+        :param message: 消息体
+        :param torrents: 种子列表
+        :return: 成功或失败
+        """
+        return self.synologychat.send_torrents_msg(title=message.title, torrents=torrents, userid=message.userid)

app/modules/synologychat/synologychat.py

@@ -0,0 +1,203 @@
+import json
+import re
+from typing import Optional, List
+from urllib.parse import quote
+from threading import Lock
+
+from app.core.config import settings
+from app.core.context import MediaInfo, Context
+from app.core.metainfo import MetaInfo
+from app.log import logger
+from app.utils.http import RequestUtils
+from app.utils.singleton import Singleton
+from app.utils.string import StringUtils
+
+lock = Lock()
+
+
+class SynologyChat(metaclass=Singleton):
+    def __init__(self):
+        self._req = RequestUtils(content_type="application/x-www-form-urlencoded")
+        self._webhook_url = settings.SYNOLOGYCHAT_WEBHOOK
+        self._token = settings.SYNOLOGYCHAT_TOKEN
+        if self._webhook_url:
+            self._domain = StringUtils.get_base_url(self._webhook_url)
+
+    def check_token(self, token: str) -> bool:
+        return True if token == self._token else False
+
+    def send_msg(self, title: str, text: str = "", image: str = "", userid: str = "") -> Optional[bool]:
+        """
+        发送Telegram消息
+        :param title: 消息标题
+        :param text: 消息内容
+        :param image: 消息图片地址
+        :param userid: 用户ID，如有则只发消息给该用户
+        :user_id: 发送消息的目标用户ID，为空则发给管理员
+        """
+        if not title and not text:
+            logger.error("标题和内容不能同时为空")
+            return False
+        if not self._webhook_url or not self._token:
+            return False
+        try:
+            # 拼装消息内容
+            titles = str(title).split('\n')
+            if len(titles) > 1:
+                title = titles[0]
+                if not text:
+                    text = "\n".join(titles[1:])
+                else:
+                    text = f"%s\n%s" % ("\n".join(titles[1:]), text)
+
+            if text:
+                caption = "*%s*\n%s" % (title, text.replace("\n\n", "\n"))
+            else:
+                caption = title
+            payload_data = {'text': quote(caption)}
+            if image:
+                payload_data['file_url'] = quote(image)
+            if userid:
+                payload_data['user_ids'] = [int(userid)]
+            else:
+                userids = self.__get_bot_users()
+                if not userids:
+                    logger.error("SynologyChat机器人没有对任何用户可见")
+                    return False
+                payload_data['user_ids'] = userids
+
+            return self.__send_request(payload_data)
+
+        except Exception as msg_e:
+            logger.error(f"SynologyChat发送消息错误：{str(msg_e)}")
+            return False
+
+    def send_meidas_msg(self, medias: List[MediaInfo], userid: str = "", title: str = "") -> Optional[bool]:
+        """
+        发送列表类消息
+        """
+        if not medias:
+            return False
+        if not self._webhook_url or not self._token:
+            return False
+        try:
+            if not title or not isinstance(medias, list):
+                return False
+            index, image, caption = 1, "", "*%s*" % title
+            for media in medias:
+                if not image:
+                    image = media.get_message_image()
+                if media.vote_average:
+                    caption = "%s\n%s. <%s|%s>\n_%s，%s_" % (caption,
+                                                            index,
+                                                            media.detail_link,
+                                                            media.title_year,
+                                                            f"类型：{media.type.value}",
+                                                            f"评分：{media.vote_average}")
+                else:
+                    caption = "%s\n%s. <%s|%s>\n_%s_" % (caption,
+                                                         index,
+                                                         media.detail_link,
+                                                         media.title_year,
+                                                         f"类型：{media.type.value}")
+                index += 1
+
+            if userid:
+                userids = [int(userid)]
+            else:
+                userids = self.__get_bot_users()
+            payload_data = {
+                "text": quote(caption),
+                "user_ids": userids
+            }
+            return self.__send_request(payload_data)
+
+        except Exception as msg_e:
+            logger.error(f"SynologyChat发送消息错误：{str(msg_e)}")
+            return False
+
+    def send_torrents_msg(self, torrents: List[Context],
+                          userid: str = "", title: str = "") -> Optional[bool]:
+        """
+        发送列表消息
+        """
+        if not self._webhook_url or not self._token:
+            return None
+
+        if not torrents:
+            return False
+
+        try:
+            index, caption = 1, "*%s*" % title
+            for context in torrents:
+                torrent = context.torrent_info
+                site_name = torrent.site_name
+                meta = MetaInfo(torrent.title, torrent.description)
+                link = torrent.page_url
+                title = f"{meta.season_episode} " \
+                        f"{meta.resource_term} " \
+                        f"{meta.video_term} " \
+                        f"{meta.release_group}"
+                title = re.sub(r"\s+", " ", title).strip()
+                free = torrent.volume_factor
+                seeder = f"{torrent.seeders}↑"
+                description = torrent.description
+                caption = f"{caption}\n{index}.【{site_name}】<{link}|{title}> " \
+                          f"{StringUtils.str_filesize(torrent.size)} {free} {seeder}\n" \
+                          f"_{description}_"
+                index += 1
+
+            if userid:
+                userids = [int(userid)]
+            else:
+                userids = self.__get_bot_users()
+
+            payload_data = {
+                "text": quote(caption),
+                "user_ids": userids
+            }
+            return self.__send_request(payload_data)
+        except Exception as msg_e:
+            logger.error(f"SynologyChat发送消息错误：{str(msg_e)}")
+            return False
+
+    def __get_bot_users(self):
+        """
+        查询机器人可见的用户列表
+        """
+        if not self._domain or not self._token:
+            return []
+        req_url = f"{self._domain}" \
+                  f"/webapi/entry.cgi?api=SYNO.Chat.External&method=user_list&version=2&token=" \
+                  f"{self._token}"
+        ret = self._req.get_res(url=req_url)
+        if ret and ret.status_code == 200:
+            users = ret.json().get("data", {}).get("users", []) or []
+            return [user.get("user_id") for user in users]
+        else:
+            return []
+
+    def __send_request(self, payload_data):
+        """
+        发送消息请求
+        """
+        payload = f"payload={json.dumps(payload_data)}"
+        ret = self._req.post_res(url=self._webhook_url, data=payload)
+        if ret and ret.status_code == 200:
+            result = ret.json()
+            if result:
+                errno = result.get('error', {}).get('code')
+                errmsg = result.get('error', {}).get('errors')
+                if not errno:
+                    return True
+                logger.error(f"SynologyChat返回错误：{errno}-{errmsg}")
+                return False
+            else:
+                logger.error(f"SynologyChat返回：{ret.text}")
+                return False
+        elif ret is not None:
+            logger.error(f"SynologyChat请求失败，错误码：{ret.status_code}，错误原因：{ret.reason}")
+            return False
+        else:
+            logger.error(f"SynologyChat请求失败，未获取到返回信息")
+            return False

app/modules/telegram/telegram.py

@@ -52,7 +52,7 @@ class Telegram(metaclass=Singleton):
                 定义线程函数来运行 infinity_polling
                 """
                 try:
-                    _bot.infinity_polling(long_polling_timeout=10)
+                    _bot.infinity_polling(long_polling_timeout=30, logger_level=None)
                 except Exception as err:
                     logger.error(f"Telegram消息接收服务异常：{err}")
 

app/modules/transmission/__init__.py

@@ -131,7 +131,7 @@ class TransmissionModule(_ModuleBase):
                     title=torrent.name,
                     path=Path(torrent.download_dir) / torrent.name,
                     hash=torrent.hashString,
-                    tags=torrent.labels
+                    tags=",".join(torrent.labels or [])
                 ))
         elif status == TorrentStatus.DOWNLOADING:
             # 获取正在下载的任务

app/plugins/autosignin/__init__.py

@@ -14,6 +14,7 @@ from ruamel.yaml import CommentedMap
 from app import schemas
 from app.core.config import settings
 from app.core.event import EventManager, eventmanager, Event
+from app.db.models.site import Site
 from app.helper.browser import PlaywrightHelper
 from app.helper.cloudflare import under_challenge
 from app.helper.module import ModuleHelper
@@ -85,11 +86,18 @@ class AutoSignIn(_PluginBase):
             self._onlyonce = config.get("onlyonce")
             self._notify = config.get("notify")
             self._queue_cnt = config.get("queue_cnt") or 5
-            self._sign_sites = config.get("sign_sites")
-            self._login_sites = config.get("login_sites")
+            self._sign_sites = config.get("sign_sites") or []
+            self._login_sites = config.get("login_sites") or []
             self._retry_keyword = config.get("retry_keyword")
             self._clean = config.get("clean")
 
+            # 过滤掉已删除的站点
+            all_sites = [site for site in self.sites.get_indexers() if not site.get("public")]
+            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]
+            # 保存配置
+            self.__update_config()
+
         # 加载模块
         if self._enabled or self._onlyonce:
 
@@ -237,8 +245,8 @@ class AutoSignIn(_PluginBase):
         拼装插件配置页面，需要返回两块数据：1、页面配置；2、数据结构
         """
         # 站点的可选项
-        site_options = [{"title": site.get("name"), "value": site.get("id")}
-                        for site in self.sites.get_indexers()]
+        site_options = [{"title": site.name, "value": site.id}
+                        for site in Site.list_order_by_pri(self.db)]
         return [
             {
                 'component': 'VForm',
@@ -575,6 +583,7 @@ class AutoSignIn(_PluginBase):
         yesterday_str = yesterday.strftime('%Y-%m-%d')
         # 删除昨天历史
         self.del_data(key=type + "-" + yesterday_str)
+        self.del_data(key=f"{yesterday.month}月{yesterday.day}日")
 
         # 查看今天有没有签到|登录历史
         today = today.strftime('%Y-%m-%d')
@@ -591,11 +600,6 @@ class AutoSignIn(_PluginBase):
         # 今日没数据
         if not today_history or self._clean:
             logger.info(f"今日 {today} 未{type}，开始{type}已选站点")
-            # 过滤删除的站点
-            if type == "签到":
-                self._sign_sites = [site.get("id") for site in do_sites if site]
-            if type == "登录":
-                self._login_sites = [site.get("id") for site in do_sites if site]
             if self._clean:
                 # 关闭开关
                 self._clean = False
@@ -634,11 +638,22 @@ class AutoSignIn(_PluginBase):
             logger.info(f"站点{type}任务完成！")
             # 获取今天的日期
             key = f"{datetime.now().month}月{datetime.now().day}日"
+            today_data = self.get_data(key)
+            if today_data:
+                if not isinstance(today_data, list):
+                    today_data = [today_data]
+                for s in status:
+                    today_data.append({
+                        "site": s[0],
+                        "status": s[1]
+                    })
+            else:
+                today_data = [{
+                    "site": s[0],
+                    "status": s[1]
+                } for s in status]
             # 保存数据
-            self.save_data(key, [{
-                "site": s[0],
-                "status": s[1]
-            } for s in status])
+            self.save_data(key, today_data)
 
             # 命中重试词的站点id
             retry_sites = []
@@ -801,6 +816,10 @@ class AutoSignIn(_PluginBase):
                         return f"无法通过Cloudflare！"
                     return f"仿真登录失败，Cookie已失效！"
                 else:
+                    # 判断是否已签到
+                    if re.search(r'已签|签到已得', page_source, re.IGNORECASE) \
+                            or SiteUtils.is_checkin(page_source):
+                        return f"签到成功"
                     return "仿真签到成功"
             else:
                 res = RequestUtils(cookies=site_cookie,
@@ -930,30 +949,25 @@ class AutoSignIn(_PluginBase):
         site_id = event.event_data.get("site_id")
         config = self.get_config()
         if config:
-            sign_sites = config.get("sign_sites")
-            if sign_sites:
-                if isinstance(sign_sites, str):
-                    sign_sites = [sign_sites]
+            self._sign_sites = self.__remove_site_id(config.get("sign_sites") or [], site_id)
+            self._login_sites = self.__remove_site_id(config.get("login_sites") or [], site_id)
+            # 保存配置
+            self.__update_config()
 
-                # 删除对应站点
-                if site_id:
-                    sign_sites = [site for site in sign_sites if int(site) != int(site_id)]
-                else:
-                    # 清空
-                    sign_sites = []
+    def __remove_site_id(self, do_sites, site_id):
+        if do_sites:
+            if isinstance(do_sites, str):
+                do_sites = [do_sites]
 
-                # 若无站点，则停止
-                if len(sign_sites) == 0:
-                    self._enabled = False
+            # 删除对应站点
+            if site_id:
+                do_sites = [site for site in do_sites if int(site) != int(site_id)]
+            else:
+                # 清空
+                do_sites = []
 
-                # 保存配置
-                self.update_config(
-                    {
-                        "enabled": self._enabled,
-                        "notify": self._notify,
-                        "cron": self._cron,
-                        "onlyonce": self._onlyonce,
-                        "queue_cnt": self._queue_cnt,
-                        "sign_sites": sign_sites
-                    }
-                )
+            # 若无站点，则停止
+            if len(do_sites) == 0:
+                self._enabled = False
+
+        return do_sites

app/plugins/bestfilmversion/__init__.py

@@ -131,130 +131,130 @@ class BestFilmVersion(_PluginBase):
         拼装插件配置页面，需要返回两块数据：1、页面配置；2、数据结构
         """
         return [
-                   {
-                       'component': 'VForm',
-                       'content': [
-                           {
-                               'component': 'VRow',
-                               'content': [
-                                   {
-                                       'component': 'VCol',
-                                       'props': {
-                                           'cols': 12,
-                                           'md': 3
-                                       },
-                                       'content': [
-                                           {
-                                               'component': 'VSwitch',
-                                               'props': {
-                                                   'model': 'enabled',
-                                                   'label': '启用插件',
-                                               }
-                                           }
-                                       ]
-                                   },
-                                   {
-                                       'component': 'VCol',
-                                       'props': {
-                                           'cols': 12,
-                                           'md': 3
-                                       },
-                                       'content': [
-                                           {
-                                               'component': 'VSwitch',
-                                               'props': {
-                                                   'model': 'notify',
-                                                   'label': '发送通知',
-                                               }
-                                           }
-                                       ]
-                                   },
-                                   {
-                                       'component': 'VCol',
-                                       'props': {
-                                           'cols': 12,
-                                           'md': 3
-                                       },
-                                       'content': [
-                                           {
-                                               'component': 'VSwitch',
-                                               'props': {
-                                                   'model': 'only_once',
-                                                   'label': '立即运行一次',
-                                               }
-                                           }
-                                       ]
-                                   },
-                                   {
-                                       'component': 'VCol',
-                                       'props': {
-                                           'cols': 12,
-                                           'md': 3
-                                       },
-                                       'content': [
-                                           {
-                                               'component': 'VSwitch',
-                                               'props': {
-                                                   'model': 'webhook_enabled',
-                                                   'label': 'Webhook',
-                                               }
-                                           }
-                                       ]
-                                   }
-                               ]
-                           },
-                           {
-                               'component': 'VRow',
-                               'content': [
-                                   {
-                                       'component': 'VCol',
-                                       'props': {
-                                           'cols': 12,
-                                       },
-                                       'content': [
-                                           {
-                                               'component': 'VTextField',
-                                               'props': {
-                                                   'model': 'cron',
-                                                   'label': '执行周期',
-                                                   'placeholder': '5位cron表达式，留空自动'
-                                               }
-                                           }
-                                       ]
-                                   }
-                               ]
-                           },
-                           {
-                               'component': 'VRow',
-                               'content': [
-                                   {
-                                       'component': 'VCol',
-                                       'props': {
-                                           'cols': 12,
-                                       },
-                                       'content': [
-                                           {
-                                               'component': 'VAlert',
-                                               'props': {
-                                                   'text': '支持主动定时获取媒体库数据和Webhook实时触发两种方式，两者只能选其一，'
-                                                           'Webhook需要在媒体服务器设置发送Webhook报文。'
-                                                           'Plex使用主动获取时，建议执行周期设置大于1小时，'
-                                                           '收藏Api调用Plex官网接口，有频率限制。'
-                                               }
-                                           }
-                                       ]
-                                   }
-                               ]
-                           }
-                       ]
-                   }
-               ], {
-                   "enabled": False,
-                   "notify": False,
-                   "cron": "*/30 * * * *",
-                   "webhook_enabled": False,
-                   "only_once": False
-               }
+            {
+                'component': 'VForm',
+                'content': [
+                    {
+                        'component': 'VRow',
+                        'content': [
+                            {
+                                'component': 'VCol',
+                                'props': {
+                                    'cols': 12,
+                                    'md': 3
+                                },
+                                'content': [
+                                    {
+                                        'component': 'VSwitch',
+                                        'props': {
+                                            'model': 'enabled',
+                                            'label': '启用插件',
+                                        }
+                                    }
+                                ]
+                            },
+                            {
+                                'component': 'VCol',
+                                'props': {
+                                    'cols': 12,
+                                    'md': 3
+                                },
+                                'content': [
+                                    {
+                                        'component': 'VSwitch',
+                                        'props': {
+                                            'model': 'notify',
+                                            'label': '发送通知',
+                                        }
+                                    }
+                                ]
+                            },
+                            {
+                                'component': 'VCol',
+                                'props': {
+                                    'cols': 12,
+                                    'md': 3
+                                },
+                                'content': [
+                                    {
+                                        'component': 'VSwitch',
+                                        'props': {
+                                            'model': 'only_once',
+                                            'label': '立即运行一次',
+                                        }
+                                    }
+                                ]
+                            },
+                            {
+                                'component': 'VCol',
+                                'props': {
+                                    'cols': 12,
+                                    'md': 3
+                                },
+                                'content': [
+                                    {
+                                        'component': 'VSwitch',
+                                        'props': {
+                                            'model': 'webhook_enabled',
+                                            'label': 'Webhook',
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    },
+                    {
+                        'component': 'VRow',
+                        'content': [
+                            {
+                                'component': 'VCol',
+                                'props': {
+                                    'cols': 12,
+                                },
+                                'content': [
+                                    {
+                                        'component': 'VTextField',
+                                        'props': {
+                                            'model': 'cron',
+                                            'label': '执行周期',
+                                            'placeholder': '5位cron表达式，留空自动'
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    },
+                    {
+                        'component': 'VRow',
+                        'content': [
+                            {
+                                'component': 'VCol',
+                                'props': {
+                                    'cols': 12,
+                                },
+                                'content': [
+                                    {
+                                        'component': 'VAlert',
+                                        'props': {
+                                            'text': '支持主动定时获取媒体库数据和Webhook实时触发两种方式，两者只能选其一，'
+                                                    'Webhook需要在媒体服务器设置发送Webhook报文。'
+                                                    'Plex使用主动获取时，建议执行周期设置大于1小时，'
+                                                    '收藏Api调用Plex官网接口，有频率限制。'
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                ]
+            }
+        ], {
+            "enabled": False,
+            "notify": False,
+            "cron": "*/30 * * * *",
+            "webhook_enabled": False,
+            "only_once": False
+        }
 
     def get_page(self) -> List[dict]:
         """
@@ -386,81 +386,85 @@ class BestFilmVersion(_PluginBase):
             # 读取历史记录
             history = self.get_data('history') or []
 
-            all_item = []
+            # 媒体服务器类型，多个以,分隔
+            if not settings.MEDIASERVER:
+                return
+            media_servers = settings.MEDIASERVER.split(',')
+
             # 读取收藏
-            if settings.MEDIASERVER == 'jellyfin':
-                self.jellyfin_get_items(all_item)
-            elif settings.MEDIASERVER == 'emby':
-                self.emby_get_items(all_item)
-            else:
-                resp = self.plex_get_watchlist()
-                if not resp:
-                    return
-                all_item.extend(resp)
+            all_items = {}
+            for media_server in media_servers:
+                if media_server == 'jellyfin':
+                    all_items['jellyfin'] = self.jellyfin_get_items()
+                elif media_server == 'emby':
+                    all_items['emby'] = self.emby_get_items()
+                else:
+                    all_items['plex'] = self.plex_get_watchlist()
 
             def function(y, x):
                 return y if (x['Name'] in [i['Name'] for i in y]) else (lambda z, u: (z.append(u), z))(y, x)[1]
 
-            # all_item 根据电影名去重
-            result = reduce(function, all_item, [])
-
-            for data in result:
-                # 检查缓存
-                if data.get('Name') in caches:
-                    continue
-
-                # 获取详情
-                if settings.MEDIASERVER == 'jellyfin':
-                    item_info_resp = Jellyfin().get_iteminfo(itemid=data.get('Id'))
-                elif settings.MEDIASERVER == 'emby':
-                    item_info_resp = Emby().get_iteminfo(itemid=data.get('Id'))
-                else:
-                    item_info_resp = self.plex_get_iteminfo(itemid=data.get('Id'))
-
-                logger.info(f'BestFilmVersion插件 item打印 {item_info_resp}')
-                if not item_info_resp:
-                    continue
-
-                # 只接受Movie类型
-                if data.get('Type') != 'Movie':
-                    continue
-
-                # 获取tmdb_id
-                media_info_ids = item_info_resp.get('ExternalUrls')
-                if not media_info_ids:
-                    continue
-                for media_info_id in media_info_ids:
-                    if 'TheMovieDb' != media_info_id.get('Name'):
+            # 处理所有结果
+            for server, all_item in all_items.items():
+                # all_item 根据电影名去重
+                result = reduce(function, all_item, [])
+                for data in result:
+                    # 检查缓存
+                    if data.get('Name') in caches:
                         continue
-                    tmdb_find_id = str(media_info_id.get('Url')).split('/')
-                    tmdb_find_id.reverse()
-                    tmdb_id = tmdb_find_id[0]
-                    # 识别媒体信息
-                    mediainfo: MediaInfo = self.chain.recognize_media(tmdbid=tmdb_id, mtype=MediaType.MOVIE)
-                    if not mediainfo:
-                        logger.warn(f'未识别到媒体信息，标题：{data.get("Name")}，tmdbID：{tmdb_id}')
+
+                    # 获取详情
+                    if server == 'jellyfin':
+                        item_info_resp = Jellyfin().get_iteminfo(itemid=data.get('Id'))
+                    elif server == 'emby':
+                        item_info_resp = Emby().get_iteminfo(itemid=data.get('Id'))
+                    else:
+                        item_info_resp = self.plex_get_iteminfo(itemid=data.get('Id'))
+
+                    logger.info(f'BestFilmVersion插件 item打印 {item_info_resp}')
+                    if not item_info_resp:
                         continue
-                    # 添加订阅
-                    self.subscribechain.add(mtype=MediaType.MOVIE,
-                                            title=mediainfo.title,
-                                            year=mediainfo.year,
-                                            tmdbid=mediainfo.tmdb_id,
-                                            best_version=True,
-                                            username="收藏洗版",
-                                            exist_ok=True)
-                    # 加入缓存
-                    caches.append(data.get('Name'))
-                    # 存储历史记录
-                    if mediainfo.tmdb_id not in [h.get("tmdbid") for h in history]:
-                        history.append({
-                            "title": mediainfo.title,
-                            "type": mediainfo.type.value,
-                            "year": mediainfo.year,
-                            "poster": mediainfo.get_poster_image(),
-                            "overview": mediainfo.overview,
-                            "tmdbid": mediainfo.tmdb_id,
-                            "time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-                        })
+
+                    # 只接受Movie类型
+                    if data.get('Type') != 'Movie':
+                        continue
+
+                    # 获取tmdb_id
+                    media_info_ids = item_info_resp.get('ExternalUrls')
+                    if not media_info_ids:
+                        continue
+                    for media_info_id in media_info_ids:
+                        if 'TheMovieDb' != media_info_id.get('Name'):
+                            continue
+                        tmdb_find_id = str(media_info_id.get('Url')).split('/')
+                        tmdb_find_id.reverse()
+                        tmdb_id = tmdb_find_id[0]
+                        # 识别媒体信息
+                        mediainfo: MediaInfo = self.chain.recognize_media(tmdbid=tmdb_id, mtype=MediaType.MOVIE)
+                        if not mediainfo:
+                            logger.warn(f'未识别到媒体信息，标题：{data.get("Name")}，tmdbID：{tmdb_id}')
+                            continue
+                        # 添加订阅
+                        self.subscribechain.add(mtype=MediaType.MOVIE,
+                                                title=mediainfo.title,
+                                                year=mediainfo.year,
+                                                tmdbid=mediainfo.tmdb_id,
+                                                best_version=True,
+                                                username="收藏洗版",
+                                                exist_ok=True)
+                        # 加入缓存
+                        caches.append(data.get('Name'))
+                        # 存储历史记录
+                        if mediainfo.tmdb_id not in [h.get("tmdbid") for h in history]:
+                            history.append({
+                                "title": mediainfo.title,
+                                "type": mediainfo.type.value,
+                                "year": mediainfo.year,
+                                "poster": mediainfo.get_poster_image(),
+                                "overview": mediainfo.overview,
+                                "tmdbid": mediainfo.tmdb_id,
+                                "time": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+                            })
             # 保存历史记录
             self.save_data('history', history)
             # 保存缓存
@@ -468,13 +472,14 @@ class BestFilmVersion(_PluginBase):
         finally:
             lock.release()
 
-    def jellyfin_get_items(self, all_item):
+    def jellyfin_get_items(self) -> List[dict]:
         # 获取所有user
         users_url = "{HOST}Users?&apikey={APIKEY}"
         users = self.get_users(Jellyfin().get_data(users_url))
         if not users:
             logger.info(f"bestfilmversion/users_url: {users_url}")
-            return
+            return []
+        all_items = []
         for user in users:
             # 根据加入日期 降序排序
             url = "{HOST}Users/" + user + "/Items?SortBy=DateCreated%2CSortName" \
@@ -490,14 +495,16 @@ class BestFilmVersion(_PluginBase):
             resp = self.get_items(Jellyfin().get_data(url))
             if not resp:
                 continue
-            all_item.extend(resp)
+            all_items.extend(resp)
+        return all_items
 
-    def emby_get_items(self, all_item):
+    def emby_get_items(self) -> List[dict]:
         # 获取所有user
         get_users_url = "{HOST}Users?&api_key={APIKEY}"
         users = self.get_users(Emby().get_data(get_users_url))
         if not users:
-            return
+            return []
+        all_items = []
         for user in users:
             # 根据加入日期 降序排序
             url = "{HOST}emby/Users/" + user + "/Items?SortBy=DateCreated%2CSortName" \
@@ -512,7 +519,8 @@ class BestFilmVersion(_PluginBase):
             resp = self.get_items(Emby().get_data(url))
             if not resp:
                 continue
-            all_item.extend(resp)
+            all_items.extend(resp)
+        return all_items
 
     @staticmethod
     def get_items(resp: Response):
@@ -538,7 +546,7 @@ class BestFilmVersion(_PluginBase):
             return []
 
     @staticmethod
-    def plex_get_watchlist():
+    def plex_get_watchlist() -> List[dict]:
         # 根据加入日期 降序排序
         url = f"https://metadata.provider.plex.tv/library/sections/watchlist/all?type=1&sort=addedAt%3Adesc" \
               f"&X-Plex-Container-Start=0&X-Plex-Container-Size=50" \

app/plugins/cloudflarespeedtest/__init__.py

@@ -1,12 +1,17 @@
 import os
+import subprocess
+import time
+import zipfile
 from datetime import datetime, timedelta
 from pathlib import Path
 from typing import List, Tuple, Dict, Any
 
 import pytz
+import requests
 from apscheduler.schedulers.background import BackgroundScheduler
 from apscheduler.triggers.cron import CronTrigger
 from python_hosts import Hosts, HostsEntry
+from requests import Response
 
 from app.core.config import settings
 from app.log import logger
@@ -79,20 +84,25 @@ class CloudflareSpeedTest(_PluginBase):
         if self.get_state() or self._onlyonce:
             self._scheduler = BackgroundScheduler(timezone=settings.TZ)
 
-            if self.get_state() and self._cron:
-                logger.info(f"Cloudflare CDN优选服务启动，周期：{self._cron}")
-                self._scheduler.add_job(func=self.__cloudflareSpeedTest,
-                                        trigger=CronTrigger.from_crontab(self._cron),
-                                        name="Cloudflare优选")
+            try:
+                if self.get_state() and self._cron:
+                    logger.info(f"Cloudflare CDN优选服务启动，周期：{self._cron}")
+                    self._scheduler.add_job(func=self.__cloudflareSpeedTest,
+                                            trigger=CronTrigger.from_crontab(self._cron),
+                                            name="Cloudflare优选")
 
-            if self._onlyonce:
-                logger.info(f"Cloudflare CDN优选服务启动，立即运行一次")
-                self._scheduler.add_job(func=self.__cloudflareSpeedTest, trigger='date',
-                                        run_date=datetime.now(tz=pytz.timezone(settings.TZ)) + timedelta(seconds=3),
-                                        name="Cloudflare优选")
-                # 关闭一次性开关
-                self._onlyonce = False
-                self.__update_config()
+                if self._onlyonce:
+                    logger.info(f"Cloudflare CDN优选服务启动，立即运行一次")
+                    self._scheduler.add_job(func=self.__cloudflareSpeedTest, trigger='date',
+                                            run_date=datetime.now(tz=pytz.timezone(settings.TZ)) + timedelta(seconds=3),
+                                            name="Cloudflare优选")
+                    # 关闭一次性开关
+                    self._onlyonce = False
+                    self.__update_config()
+            except Exception as err:
+                logger.error(f"Cloudflare CDN优选服务出错：{str(err)}")
+                self.systemmessage.put(f"Cloudflare CDN优选服务出错：{str(err)}")
+                return
 
             # 启动任务
             if self._scheduler.get_jobs():
@@ -142,13 +152,35 @@ class CloudflareSpeedTest(_PluginBase):
         if err_flag:
             logger.info("正在进行CLoudflare CDN优选，请耐心等待")
             # 执行优选命令，-dd不测速
-            cf_command = f'cd {self._cf_path} && chmod a+x {self._binary_name} && ./{self._binary_name} {self._additional_args} -o {self._result_file}' + (
-                f' -f {self._cf_ipv4}' if self._ipv4 else '') + (f' -f {self._cf_ipv6}' if self._ipv6 else '')
+            if SystemUtils.is_windows():
+                cf_command = f'cd \"{self._cf_path}\" && CloudflareST {self._additional_args} -o \"{self._result_file}\"' + (
+                    f' -f \"{self._cf_ipv4}\"' if self._ipv4 else '') + (f' -f \"{self._cf_ipv6}\"' if self._ipv6 else '')
+            else:
+                cf_command = f'cd {self._cf_path} && chmod a+x {self._binary_name} && ./{self._binary_name} {self._additional_args} -o {self._result_file}' + (
+                    f' -f {self._cf_ipv4}' if self._ipv4 else '') + (f' -f {self._cf_ipv6}' if self._ipv6 else '')
             logger.info(f'正在执行优选命令 {cf_command}')
-            os.system(cf_command)
+            if SystemUtils.is_windows():
+                process = subprocess.Popen(cf_command, shell=True)
+                # 执行命令后无法退出 采用异步和设置超时方案
+                # 设置超时时间为120秒
+                if cf_command.__contains__("-dd"):
+                    time.sleep(120)
+                else:
+                    time.sleep(600)
+                # 如果没有在120秒内完成任务，那么杀死该进程
+                if process.poll() is None:
+                    os.system('taskkill /F /IM CloudflareST.exe')
+            else:
+                os.system(cf_command)
 
             # 获取优选后最优ip
-            best_ip = SystemUtils.execute("sed -n '2,1p' " + self._result_file + " | awk -F, '{print $1}'")
+            if SystemUtils.is_windows():
+                powershell_command = f"powershell.exe -Command \"Get-Content \'{self._result_file}\' | Select-Object -Skip 1 -First 1 | Write-Output\""
+                logger.info(f'正在执行powershell命令 {powershell_command}')
+                best_ip = SystemUtils.execute(powershell_command)
+                best_ip = best_ip.split(',')[0]
+            else:
+                best_ip = SystemUtils.execute("sed -n '2,1p' " + self._result_file + " | awk -F, '{print $1}'")
             logger.info(f"\n获取到最优ip==>[{best_ip}]")
 
             # 替换自定义Hosts插件数据库hosts
@@ -246,7 +278,10 @@ class CloudflareSpeedTest(_PluginBase):
         # 是否重新安装
         if self._re_install:
             install_flag = True
-            os.system(f'rm -rf {self._cf_path}')
+            if SystemUtils.is_windows():
+                os.system(f'rd /s /q \"{self._cf_path}\"')
+            else:
+                os.system(f'rm -rf {self._cf_path}')
             logger.info(f'删除CloudflareSpeedTest目录 {self._cf_path}，开始重新安装')
 
         # 判断目录是否存在
@@ -277,7 +312,8 @@ class CloudflareSpeedTest(_PluginBase):
 
         # 重装后数据库有版本数据，但是本地没有则重装
         if not install_flag and release_version == self._version and not Path(
-                f'{self._cf_path}/{self._binary_name}').exists():
+                f'{self._cf_path}/{self._binary_name}').exists() and not Path(
+                f'{self._cf_path}/CloudflareST.exe').exists():
             logger.warn(f"未检测到CloudflareSpeedTest本地版本，重新安装")
             install_flag = True
 
@@ -287,9 +323,11 @@ class CloudflareSpeedTest(_PluginBase):
 
         # 检查环境、安装
         if SystemUtils.is_windows():
-            # todo
-            logger.error(f"CloudflareSpeedTest暂不支持windows平台")
-            return False, None
+            # windows
+            cf_file_name = 'CloudflareST_windows_amd64.zip'
+            download_url = f'{self._release_prefix}/{release_version}/{cf_file_name}'
+            return self.__os_install(download_url, cf_file_name, release_version,
+                                     f"ditto -V -x -k --sequesterRsrc {self._cf_path}/{cf_file_name} {self._cf_path}")
         elif SystemUtils.is_macos():
             # mac
             uname = SystemUtils.execute('uname -m')
@@ -317,14 +355,31 @@ class CloudflareSpeedTest(_PluginBase):
             proxies = settings.PROXY
             https_proxy = proxies.get("https") if proxies and proxies.get("https") else None
             if https_proxy:
-                os.system(
-                    f'wget -P {self._cf_path} --no-check-certificate -e use_proxy=yes -e https_proxy={https_proxy} {download_url}')
+                if SystemUtils.is_windows():
+                    self.__get_windows_cloudflarest(download_url, proxies)
+                else:
+                    os.system(
+                        f'wget -P {self._cf_path} --no-check-certificate -e use_proxy=yes -e https_proxy={https_proxy} {download_url}')
             else:
-                os.system(f'wget -P {self._cf_path} https://ghproxy.com/{download_url}')
+                if SystemUtils.is_windows():
+                    self.__get_windows_cloudflarest(download_url, proxies)
+                else:
+                    os.system(f'wget -P {self._cf_path} https://ghproxy.com/{download_url}')
 
         # 判断是否下载好安装包
         if Path(f'{self._cf_path}/{cf_file_name}').exists():
             try:
+                if SystemUtils.is_windows():
+                    with zipfile.ZipFile(f'{self._cf_path}/{cf_file_name}', 'r') as zip_ref:
+                        # 解压ZIP文件中的所有文件到指定目录
+                        zip_ref.extractall(self._cf_path)
+                    if Path(f'{self._cf_path}\\CloudflareST.exe').exists():
+                        logger.info(f"CloudflareSpeedTest安装成功，当前版本：{release_version}")
+                        return True, release_version
+                    else:
+                        logger.error(f"CloudflareSpeedTest安装失败，请检查")
+                        os.system(f'rd /s /q \"{self._cf_path}\"')
+                        return False, None
                 # 解压
                 os.system(f'{unzip_command}')
                 # 删除压缩包
@@ -338,23 +393,42 @@ class CloudflareSpeedTest(_PluginBase):
                     return False, None
             except Exception as err:
                 # 如果升级失败但是有可执行文件CloudflareST，则可继续运行，反之停止
-                if Path(f'{self._cf_path}/{self._binary_name}').exists():
+                if Path(f'{self._cf_path}/{self._binary_name}').exists() or \
+                        Path(f'{self._cf_path}\\CloudflareST.exe').exists():
                     logger.error(f"CloudflareSpeedTest安装失败：{str(err)}，继续使用现版本运行")
                     return True, None
                 else:
                     logger.error(f"CloudflareSpeedTest安装失败：{str(err)}，无可用版本，停止运行")
-                    os.removedirs(self._cf_path)
+                    if SystemUtils.is_windows():
+                        os.system(f'rd /s /q \"{self._cf_path}\"')
+                    else:
+                        os.removedirs(self._cf_path)
                     return False, None
         else:
             # 如果升级失败但是有可执行文件CloudflareST，则可继续运行，反之停止
-            if Path(f'{self._cf_path}/{self._binary_name}').exists():
+            if Path(f'{self._cf_path}/{self._binary_name}').exists() or \
+                    Path(f'{self._cf_path}\\CloudflareST.exe').exists():
                 logger.warn(f"CloudflareSpeedTest安装失败，存在可执行版本，继续运行")
                 return True, None
             else:
                 logger.error(f"CloudflareSpeedTest安装失败，无可用版本，停止运行")
-                os.removedirs(self._cf_path)
+                if SystemUtils.is_windows():
+                    os.system(f'rd /s /q \"{self._cf_path}\"')
+                else:
+                    os.removedirs(self._cf_path)
                 return False, None
 
+    def __get_windows_cloudflarest(self, download_url, proxies):
+        response = Response()
+        try:
+            response = requests.get(download_url, stream=True, proxies=proxies if proxies else None)
+        except requests.exceptions.RequestException as e:
+            logger.error(f"CloudflareSpeedTest下载失败：{str(e)}")
+        if response.status_code == 200:
+            with open(f'{self._cf_path}\\CloudflareST_windows_amd64.zip', 'wb') as file:
+                for chunk in response.iter_content(chunk_size=8192):
+                    file.write(chunk)
+
     @staticmethod
     def __get_release_version():
         """

app/plugins/dirmonitor/__init__.py

@@ -292,7 +292,7 @@ class DirMonitor(_PluginBase):
                     if not transferinfo:
                         logger.error("文件转移模块运行失败")
                         return
-                    if not transferinfo.target_path:
+                    if not transferinfo.success:
                         # 转移失败
                         logger.warn(f"{file_path.name} 入库失败：{transferinfo.message}")
                         # 新增转移失败历史记录
@@ -598,7 +598,7 @@ class DirMonitor(_PluginBase):
                                             'rows': 5,
                                             'placeholder': '每一行一个目录，支持两种配置方式：\n'
                                                            '监控目录\n'
-                                                           '监控目录:转移目的目录'
+                                                           '监控目录:转移目的目录（需同时在媒体库目录中配置该目的目录）'
                                         }
                                     }
                                 ]

app/plugins/iyuuautoseed/__init__.py

@@ -1,3 +1,4 @@
+import os
 import re
 from datetime import datetime, timedelta
 from threading import Event
@@ -11,6 +12,9 @@ from ruamel.yaml import CommentedMap
 
 from app.core.config import settings
 from app.helper.sites import SitesHelper
+
+from app.core.event import eventmanager
+from app.db.models.site import Site
 from app.helper.torrent import TorrentHelper
 from app.log import logger
 from app.modules.qbittorrent import Qbittorrent
@@ -18,6 +22,7 @@ from app.modules.transmission import Transmission
 from app.plugins import _PluginBase
 from app.plugins.iyuuautoseed.iyuu_helper import IyuuHelper
 from app.schemas import NotificationType
+from app.schemas.types import EventType
 from app.utils.http import RequestUtils
 from app.utils.string import StringUtils
 
@@ -60,6 +65,7 @@ class IYUUAutoSeed(_PluginBase):
     _sites = []
     _notify = False
     _nolabels = None
+    _nopaths = None
     _clearcache = False
     # 退出事件
     _event = Event()
@@ -98,14 +104,20 @@ class IYUUAutoSeed(_PluginBase):
             self._cron = config.get("cron")
             self._token = config.get("token")
             self._downloaders = config.get("downloaders")
-            self._sites = config.get("sites")
+            self._sites = config.get("sites") or []
             self._notify = config.get("notify")
             self._nolabels = config.get("nolabels")
+            self._nopaths = config.get("nopaths")
             self._clearcache = config.get("clearcache")
             self._permanent_error_caches = config.get("permanent_error_caches") or []
             self._error_caches = [] if self._clearcache else config.get("error_caches") or []
             self._success_caches = [] if self._clearcache else config.get("success_caches") or []
 
+            # 过滤掉已删除的站点
+            self._sites = [site.get("id") for site in self.sites.get_indexers() if
+                           not site.get("public") and site.get("id") in self._sites]
+            self.__update_config()
+
         # 停止现有任务
         self.stop_service()
 
@@ -163,8 +175,8 @@ class IYUUAutoSeed(_PluginBase):
         拼装插件配置页面，需要返回两块数据：1、页面配置；2、数据结构
         """
         # 站点的可选项
-        site_options = [{"title": site.get("name"), "value": site.get("id")}
-                        for site in self.sites.get_indexers()]
+        site_options = [{"title": site.name, "value": site.id}
+                        for site in Site.list_order_by_pri(self.db)]
         return [
             {
                 'component': 'VForm',
@@ -242,22 +254,6 @@ class IYUUAutoSeed(_PluginBase):
                                     }
                                 ]
                             },
-                            {
-                                'component': 'VCol',
-                                'props': {
-                                    'cols': 12
-                                },
-                                'content': [
-                                    {
-                                        'component': 'VTextField',
-                                        'props': {
-                                            'model': 'nolabels',
-                                            'label': '不辅种标签',
-                                            'placeholder': '使用,分隔多个标签'
-                                        }
-                                    }
-                                ]
-                            }
                         ]
                     },
                     {
@@ -309,6 +305,44 @@ class IYUUAutoSeed(_PluginBase):
                             }
                         ]
                     },
+                    {
+                        'component': 'VRow',
+                        'content': [
+                            {
+                                'component': 'VCol',
+                                'props': {
+                                    'cols': 12
+                                },
+                                'content': [
+                                    {
+                                        'component': 'VTextField',
+                                        'props': {
+                                            'model': 'nolabels',
+                                            'label': '不辅种标签',
+                                            'placeholder': '使用,分隔多个标签'
+                                        }
+                                    }
+                                ]
+                            },
+                            {
+                                'component': 'VCol',
+                                'props': {
+                                    'cols': 12
+                                },
+                                'content': [
+                                    {
+                                        'component': 'VTextarea',
+                                        'props': {
+                                            'model': 'nopaths',
+                                            'label': '不辅种数据文件目录',
+                                            'rows': 3,
+                                            'placeholder': '每一行一个目录'
+                                        }
+                                    }
+                                ]
+                            }
+                        ]
+                    },
                     {
                         'component': 'VRow',
                         'content': [
@@ -357,6 +391,7 @@ class IYUUAutoSeed(_PluginBase):
             "token": "",
             "downloaders": [],
             "sites": [],
+            "nopaths": "",
             "nolabels": ""
         }
 
@@ -374,6 +409,7 @@ class IYUUAutoSeed(_PluginBase):
             "sites": self._sites,
             "notify": self._notify,
             "nolabels": self._nolabels,
+            "nopaths": self._nopaths,
             "success_caches": self._success_caches,
             "error_caches": self._error_caches,
             "permanent_error_caches": self._permanent_error_caches
@@ -398,10 +434,6 @@ class IYUUAutoSeed(_PluginBase):
             return
         logger.info("开始辅种任务 ...")
 
-        # 排除已删除站点
-        self._sites = [site.get("id") for site in self.sites.get_indexers() if
-                       site.get("id") in self._sites]
-
         # 计数器初始化
         self.total = 0
         self.realtotal = 0
@@ -431,13 +463,25 @@ class IYUUAutoSeed(_PluginBase):
                     logger.info(f"种子 {hash_str} 辅种失败且已缓存，跳过 ...")
                     continue
                 save_path = self.__get_save_path(torrent, downloader)
+
+                if self._nopaths and save_path:
+                    # 过滤不需要转移的路径
+                    nopath_skip = False
+                    for nopath in self._nopaths.split('\n'):
+                        if os.path.normpath(save_path).startswith(os.path.normpath(nopath)):
+                            logger.info(f"种子 {hash_str} 保存路径 {save_path} 不需要辅种，跳过 ...")
+                            nopath_skip = True
+                            break
+                    if nopath_skip:
+                        continue
+
                 # 获取种子标签
                 torrent_labels = self.__get_label(torrent, downloader)
                 if torrent_labels and self._nolabels:
                     is_skip = False
                     for label in self._nolabels.split(','):
                         if label in torrent_labels:
-                            logger.info(f"种子 {hash_str} 含有不转移标签 {label}，跳过 ...")
+                            logger.info(f"种子 {hash_str} 含有不辅种标签 {label}，跳过 ...")
                             is_skip = True
                             break
                     if is_skip:
@@ -940,3 +984,31 @@ class IYUUAutoSeed(_PluginBase):
                 self._scheduler = None
         except Exception as e:
             print(str(e))
+
+    @eventmanager.register(EventType.SiteDeleted)
+    def site_deleted(self, event):
+        """
+        删除对应站点选中
+        """
+        site_id = event.event_data.get("site_id")
+        config = self.get_config()
+        if config:
+            sites = config.get("sites")
+            if sites:
+                if isinstance(sites, str):
+                    sites = [sites]
+
+                # 删除对应站点
+                if site_id:
+                    sites = [site for site in sites if int(site) != int(site_id)]
+                else:
+                    # 清空
+                    sites = []
+
+                # 若无站点，则停止
+                if len(sites) == 0:
+                    self._enabled = False
+
+                self._sites = sites
+                # 保存配置
+                self.__update_config()

app/plugins/libraryscraper/__init__.py

@@ -8,6 +8,7 @@ from apscheduler.schedulers.background import BackgroundScheduler
 from apscheduler.triggers.cron import CronTrigger
 
 from app.core.config import settings
+from app.core.meta import MetaBase
 from app.core.metainfo import MetaInfo
 from app.db.transferhistory_oper import TransferHistoryOper
 from app.helper.nfo import NfoReader
@@ -295,18 +296,21 @@ class LibraryScraper(_PluginBase):
                     continue
                 # 开始刮削目录
                 if sub_path.is_dir():
+                    # 判断目录是不是媒体目录
+                    dir_meta = MetaInfo(sub_path.name)
+                    if not dir_meta.name or not dir_meta.year:
+                        logger.warn(f"{sub_path} 可能不是媒体目录，请检查刮削目录配置，跳过 ...")
+                        continue
                     logger.info(f"开始刮削目录：{sub_path} ...")
-                    self.__scrape_dir(sub_path)
+                    self.__scrape_dir(path=sub_path, dir_meta=dir_meta)
                     logger.info(f"目录 {sub_path} 刮削完成")
             logger.info(f"媒体库 {path} 刮削完成")
 
-    def __scrape_dir(self, path: Path):
+    def __scrape_dir(self, path: Path, dir_meta: MetaBase):
         """
         削刮一个目录，该目录必须是媒体文件目录
         """
 
-        # 目录识别
-        dir_meta = MetaInfo(path.name)
         # 媒体信息
         mediainfo = None
 
@@ -318,14 +322,15 @@ class LibraryScraper(_PluginBase):
                 return
 
             # 识别元数据
-            meta_info = MetaInfo(file.name)
+            meta_info = MetaInfo(file.stem)
             # 合并
             meta_info.merge(dir_meta)
             # 是否刮削
             scrap_metadata = settings.SCRAP_METADATA
 
-            # 识别媒体信息
-            if not mediainfo:
+            # 没有媒体信息或者名字出现变化时，需要重新识别
+            if not mediainfo \
+                    or meta_info.name != dir_meta.name:
                 # 优先读取本地nfo文件
                 tmdbid = None
                 if meta_info.type == MediaType.MOVIE:

app/plugins/mediasyncdel/__init__.py

@@ -2,7 +2,6 @@ import datetime
 import json
 import os
 import re
-import shutil
 import time
 from pathlib import Path
 from typing import List, Tuple, Dict, Any, Optional
@@ -10,11 +9,10 @@ from typing import List, Tuple, Dict, Any, Optional
 from apscheduler.schedulers.background import BackgroundScheduler
 from apscheduler.triggers.cron import CronTrigger
 
+from app.chain.transfer import TransferChain
 from app.core.config import settings
 from app.core.event import eventmanager, Event
-from app.db.downloadhistory_oper import DownloadHistoryOper
 from app.db.models.transferhistory import TransferHistory
-from app.db.transferhistory_oper import TransferHistoryOper
 from app.log import logger
 from app.modules.emby import Emby
 from app.modules.jellyfin import Jellyfin
@@ -23,7 +21,6 @@ from app.modules.themoviedb.tmdbv3api import Episode
 from app.modules.transmission import Transmission
 from app.plugins import _PluginBase
 from app.schemas.types import NotificationType, EventType, MediaType
-from app.utils.path_utils import PathUtils
 
 
 class MediaSyncDel(_PluginBase):
@@ -58,14 +55,16 @@ class MediaSyncDel(_PluginBase):
     _del_source = False
     _exclude_path = None
     _library_path = None
+    _transferchain = None
     _transferhis = None
     _downloadhis = None
     qb = None
     tr = None
 
     def init_plugin(self, config: dict = None):
-        self._transferhis = TransferHistoryOper(self.db)
-        self._downloadhis = DownloadHistoryOper(self.db)
+        self._transferchain = TransferChain(self.db)
+        self._transferhis = self._transferchain.transferhis
+        self._downloadhis = self._transferchain.downloadhis
         self.episode = Episode()
         self.qb = Qbittorrent()
         self.tr = Transmission()
@@ -534,7 +533,7 @@ class MediaSyncDel(_PluginBase):
                         episode_num=episode_num)
 
     def __sync_del(self, media_type: str, media_name: str, media_path: str,
-                   tmdb_id: int, season_num: int, episode_num: int):
+                   tmdb_id: int, season_num: str, episode_num: str):
         """
         执行删除逻辑
         """
@@ -587,10 +586,7 @@ class MediaSyncDel(_PluginBase):
             if self._del_source:
                 # 1、直接删除源文件
                 if transferhis.src and Path(transferhis.src).suffix in settings.RMT_MEDIAEXT:
-                    source_name = os.path.basename(transferhis.src)
-                    source_path = str(transferhis.src).replace(source_name, "")
-                    self.delete_media_file(filedir=source_path,
-                                           filename=source_name)
+                    self._transferchain.delete_files(Path(transferhis.src))
                     if transferhis.download_hash:
                         try:
                             # 2、判断种子是否被删除完
@@ -654,16 +650,20 @@ class MediaSyncDel(_PluginBase):
         self.save_data("history", history)
 
     def __get_transfer_his(self, media_type: str, media_name: str, media_path: str,
-                           tmdb_id: int, season_num: int, episode_num: int):
+                           tmdb_id: int, season_num: str, episode_num: str):
         """
         查询转移记录
         """
         # 季数
-        if season_num:
+        if season_num and season_num.isdigit():
             season_num = str(season_num).rjust(2, '0')
+        else:
+            season_num = None
         # 集数
-        if episode_num:
+        if episode_num and episode_num.isdigit():
             episode_num = str(episode_num).rjust(2, '0')
+        else:
+            episode_num = None
 
         # 类型
         mtype = MediaType.MOVIE if media_type in ["Movie", "MOV"] else MediaType.TV
@@ -718,19 +718,21 @@ class MediaSyncDel(_PluginBase):
         """
         # 读取历史记录
         history = self.get_data('history') or []
-
-        # 媒体服务器类型
-        media_server = settings.MEDIASERVER
-
         last_time = self.get_data("last_time")
         del_medias = []
-        if media_server == 'emby':
-            del_medias = self.parse_emby_log(last_time)
-        elif media_server == 'jellyfin':
-            del_medias = self.parse_jellyfin_log(last_time)
-        elif media_server == 'plex':
-            # TODO plex解析日志
+
+        # 媒体服务器类型，多个以,分隔
+        if not settings.MEDIASERVER:
             return
+        media_servers = settings.MEDIASERVER.split(',')
+        for media_server in media_servers:
+            if media_server == 'emby':
+                del_medias.extend(self.parse_emby_log(last_time))
+            elif media_server == 'jellyfin':
+                del_medias.extend(self.parse_jellyfin_log(last_time))
+            elif media_server == 'plex':
+                # TODO plex解析日志
+                return
 
         if not del_medias:
             logger.error("未解析到已删除媒体信息")
@@ -825,10 +827,7 @@ class MediaSyncDel(_PluginBase):
                 if self._del_source:
                     # 1、直接删除源文件
                     if transferhis.src and Path(transferhis.src).suffix in settings.RMT_MEDIAEXT:
-                        source_name = os.path.basename(transferhis.src)
-                        source_path = str(transferhis.src).replace(source_name, "")
-                        self.delete_media_file(filedir=source_path,
-                                               filename=source_name)
+                        self._transferchain.delete_files(Path(transferhis.src))
                         if transferhis.download_hash:
                             try:
                                 # 2、判断种子是否被删除完
@@ -1187,42 +1186,6 @@ class MediaSyncDel(_PluginBase):
 
         return del_medias
 
-    @staticmethod
-    def delete_media_file(filedir: str, filename: str):
-        """
-        删除媒体文件，空目录也会被删除
-        """
-        filedir = os.path.normpath(filedir).replace("\\", "/")
-        file = os.path.join(filedir, filename)
-        try:
-            if not os.path.exists(file):
-                return False, f"{file} 不存在"
-            os.remove(file)
-            nfoname = f"{os.path.splitext(filename)[0]}.nfo"
-            nfofile = os.path.join(filedir, nfoname)
-            if os.path.exists(nfofile):
-                os.remove(nfofile)
-            # 检查空目录并删除
-            if re.findall(r"^S\d{2}|^Season", os.path.basename(filedir), re.I):
-                # 当前是季文件夹，判断并删除
-                seaon_dir = filedir
-                if seaon_dir.count('/') > 1 and not PathUtils.get_dir_files(seaon_dir, exts=settings.RMT_MEDIAEXT):
-                    shutil.rmtree(seaon_dir)
-                # 媒体文件夹
-                media_dir = os.path.dirname(seaon_dir)
-            else:
-                media_dir = filedir
-            # 检查并删除媒体文件夹，非根目录且目录大于二级，且没有媒体文件时才会删除
-            if media_dir != '/' \
-                    and media_dir.count('/') > 1 \
-                    and not re.search(r'[a-zA-Z]:/$', media_dir) \
-                    and not PathUtils.get_dir_files(media_dir, exts=settings.RMT_MEDIAEXT):
-                shutil.rmtree(media_dir)
-            return True, f"{file} 删除成功"
-        except Exception as e:
-            logger.error("删除源文件失败：%s" % str(e))
-            return True, f"{file} 删除失败"
-
     def get_state(self):
         return self._enabled
 

app/plugins/rsssubscribe/__init__.py

@@ -549,7 +549,7 @@ class RssSubscribe(_PluginBase):
                 logger.error(f"未获取到RSS数据：{url}")
                 return
             # 过滤规则
-            filter_rule = self.systemconfig.get(SystemConfigKey.FilterRules)
+            filter_rule = self.systemconfig.get(SystemConfigKey.SubscribeFilterRules)
             # 解析数据
             for result in results:
                 try:
@@ -593,7 +593,8 @@ class RssSubscribe(_PluginBase):
                     if self._filter:
                         result = self.chain.filter_torrents(
                             rule_string=filter_rule,
-                            torrent_list=[torrentinfo]
+                            torrent_list=[torrentinfo],
+                            mediainfo=mediainfo
                         )
                         if not result:
                             logger.info(f"{title} {description} 不匹配过滤规则")

app/plugins/sitestatistic/__init__.py

@@ -15,6 +15,7 @@ from app import schemas
 from app.core.config import settings
 from app.core.event import Event
 from app.core.event import eventmanager
+from app.db.models.site import Site
 from app.helper.browser import PlaywrightHelper
 from app.helper.module import ModuleHelper
 from app.helper.sites import SitesHelper
@@ -84,6 +85,11 @@ class SiteStatistic(_PluginBase):
             self._statistic_type = config.get("statistic_type") or "all"
             self._statistic_sites = config.get("statistic_sites") or []
 
+            # 过滤掉已删除的站点
+            self._statistic_sites = [site.get("id") for site in self.sites.get_indexers() if
+                                     not site.get("public") and site.get("id") in self._statistic_sites]
+            self.__update_config()
+
         if self._enabled or self._onlyonce:
             # 加载模块
             self._site_schema = ModuleHelper.load('app.plugins.sitestatistic.siteuserinfo',
@@ -177,8 +183,8 @@ class SiteStatistic(_PluginBase):
         拼装插件配置页面，需要返回两块数据：1、页面配置；2、数据结构
         """
         # 站点的可选项
-        site_options = [{"title": site.get("name"), "value": site.get("id")}
-                        for site in self.sites.get_indexers()]
+        site_options = [{"title": site.name, "value": site.id}
+                        for site in Site.list_order_by_pri(self.db)]
         return [
             {
                 'component': 'VForm',
@@ -1047,10 +1053,6 @@ class SiteStatistic(_PluginBase):
             else:
                 refresh_sites = [site for site in self.sites.get_indexers() if
                                  site.get("id") in self._statistic_sites]
-
-                # 过滤掉已删除的站点
-                self._statistic_sites = [site.get("id") for site in refresh_sites if site]
-                self.__update_config()
             if not refresh_sites:
                 return
 

app/plugins/speedlimiter/__init__.py

@@ -383,78 +383,86 @@ class SpeedLimiter(_PluginBase):
                 return
         # 当前播放的总比特率
         total_bit_rate = 0
-        # 查询播放中会话
-        playing_sessions = []
-        if settings.MEDIASERVER == "emby":
-            req_url = "{HOST}emby/Sessions?api_key={APIKEY}"
-            try:
-                res = Emby().get_data(req_url)
-                if res and res.status_code == 200:
-                    sessions = res.json()
-                    for session in sessions:
-                        if session.get("NowPlayingItem") and not session.get("PlayState", {}).get("IsPaused"):
-                            playing_sessions.append(session)
-            except Exception as e:
-                logger.error(f"获取Emby播放会话失败：{str(e)}")
-            # 计算有效比特率
-            for session in playing_sessions:
-                # 设置了不限速范围则判断session ip是否在不限速范围内
-                if self._unlimited_ips["ipv4"] or self._unlimited_ips["ipv6"]:
-                    if not self.__allow_access(self._unlimited_ips, session.get("RemoteEndPoint")) \
-                            and session.get("NowPlayingItem", {}).get("MediaType") == "Video":
-                        total_bit_rate += int(session.get("NowPlayingItem", {}).get("Bitrate") or 0)
-                # 未设置不限速范围，则默认不限速内网ip
-                elif not IpUtils.is_private_ip(session.get("RemoteEndPoint")) \
-                        and session.get("NowPlayingItem", {}).get("MediaType") == "Video":
-                    total_bit_rate += int(session.get("NowPlayingItem", {}).get("Bitrate") or 0)
-        elif settings.MEDIASERVER == "jellyfin":
-            req_url = "{HOST}Sessions?api_key={APIKEY}"
-            try:
-                res = Jellyfin().get_data(req_url)
-                if res and res.status_code == 200:
-                    sessions = res.json()
-                    for session in sessions:
-                        if session.get("NowPlayingItem") and not session.get("PlayState", {}).get("IsPaused"):
-                            playing_sessions.append(session)
-            except Exception as e:
-                logger.error(f"获取Jellyfin播放会话失败：{str(e)}")
-            # 计算有效比特率
-            for session in playing_sessions:
-                # 设置了不限速范围则判断session ip是否在不限速范围内
-                if self._unlimited_ips["ipv4"] or self._unlimited_ips["ipv6"]:
-                    if not self.__allow_access(self._unlimited_ips, session.get("RemoteEndPoint")) \
-                            and session.get("NowPlayingItem", {}).get("MediaType") == "Video":
-                        media_streams = session.get("NowPlayingItem", {}).get("MediaStreams") or []
-                        for media_stream in media_streams:
-                            total_bit_rate += int(media_stream.get("BitRate") or 0)
-                # 未设置不限速范围，则默认不限速内网ip
-                elif not IpUtils.is_private_ip(session.get("RemoteEndPoint")) \
-                        and session.get("NowPlayingItem", {}).get("MediaType") == "Video":
-                    media_streams = session.get("NowPlayingItem", {}).get("MediaStreams") or []
-                    for media_stream in media_streams:
-                        total_bit_rate += int(media_stream.get("BitRate") or 0)
-        elif settings.MEDIASERVER == "plex":
-            _plex = Plex().get_plex()
-            if _plex:
-                sessions = _plex.sessions()
-                for session in sessions:
-                    bitrate = sum([m.bitrate or 0 for m in session.media])
-                    playing_sessions.append({
-                        "type": session.TAG,
-                        "bitrate": bitrate,
-                        "address": session.player.address
-                    })
+        # 媒体服务器类型，多个以,分隔
+        if not settings.MEDIASERVER:
+            return
+        media_servers = settings.MEDIASERVER.split(',')
+        # 查询所有媒体服务器状态
+        for media_server in media_servers:
+            # 查询播放中会话
+            playing_sessions = []
+            if media_server == "emby":
+                req_url = "{HOST}emby/Sessions?api_key={APIKEY}"
+                try:
+                    res = Emby().get_data(req_url)
+                    if res and res.status_code == 200:
+                        sessions = res.json()
+                        for session in sessions:
+                            if session.get("NowPlayingItem") and not session.get("PlayState", {}).get("IsPaused"):
+                                playing_sessions.append(session)
+                except Exception as e:
+                    logger.error(f"获取Emby播放会话失败：{str(e)}")
+                    continue
                 # 计算有效比特率
                 for session in playing_sessions:
                     # 设置了不限速范围则判断session ip是否在不限速范围内
                     if self._unlimited_ips["ipv4"] or self._unlimited_ips["ipv6"]:
-                        if not self.__allow_access(self._unlimited_ips, session.get("address")) \
+                        if not self.__allow_access(self._unlimited_ips, session.get("RemoteEndPoint")) \
+                                and session.get("NowPlayingItem", {}).get("MediaType") == "Video":
+                            total_bit_rate += int(session.get("NowPlayingItem", {}).get("Bitrate") or 0)
+                    # 未设置不限速范围，则默认不限速内网ip
+                    elif not IpUtils.is_private_ip(session.get("RemoteEndPoint")) \
+                            and session.get("NowPlayingItem", {}).get("MediaType") == "Video":
+                        total_bit_rate += int(session.get("NowPlayingItem", {}).get("Bitrate") or 0)
+            elif media_server == "jellyfin":
+                req_url = "{HOST}Sessions?api_key={APIKEY}"
+                try:
+                    res = Jellyfin().get_data(req_url)
+                    if res and res.status_code == 200:
+                        sessions = res.json()
+                        for session in sessions:
+                            if session.get("NowPlayingItem") and not session.get("PlayState", {}).get("IsPaused"):
+                                playing_sessions.append(session)
+                except Exception as e:
+                    logger.error(f"获取Jellyfin播放会话失败：{str(e)}")
+                    continue
+                # 计算有效比特率
+                for session in playing_sessions:
+                    # 设置了不限速范围则判断session ip是否在不限速范围内
+                    if self._unlimited_ips["ipv4"] or self._unlimited_ips["ipv6"]:
+                        if not self.__allow_access(self._unlimited_ips, session.get("RemoteEndPoint")) \
+                                and session.get("NowPlayingItem", {}).get("MediaType") == "Video":
+                            media_streams = session.get("NowPlayingItem", {}).get("MediaStreams") or []
+                            for media_stream in media_streams:
+                                total_bit_rate += int(media_stream.get("BitRate") or 0)
+                    # 未设置不限速范围，则默认不限速内网ip
+                    elif not IpUtils.is_private_ip(session.get("RemoteEndPoint")) \
+                            and session.get("NowPlayingItem", {}).get("MediaType") == "Video":
+                        media_streams = session.get("NowPlayingItem", {}).get("MediaStreams") or []
+                        for media_stream in media_streams:
+                            total_bit_rate += int(media_stream.get("BitRate") or 0)
+            elif media_server == "plex":
+                _plex = Plex().get_plex()
+                if _plex:
+                    sessions = _plex.sessions()
+                    for session in sessions:
+                        bitrate = sum([m.bitrate or 0 for m in session.media])
+                        playing_sessions.append({
+                            "type": session.TAG,
+                            "bitrate": bitrate,
+                            "address": session.player.address
+                        })
+                    # 计算有效比特率
+                    for session in playing_sessions:
+                        # 设置了不限速范围则判断session ip是否在不限速范围内
+                        if self._unlimited_ips["ipv4"] or self._unlimited_ips["ipv6"]:
+                            if not self.__allow_access(self._unlimited_ips, session.get("address")) \
+                                    and session.get("type") == "Video":
+                                total_bit_rate += int(session.get("bitrate") or 0)
+                        # 未设置不限速范围，则默认不限速内网ip
+                        elif not IpUtils.is_private_ip(session.get("address")) \
                                 and session.get("type") == "Video":
                             total_bit_rate += int(session.get("bitrate") or 0)
-                    # 未设置不限速范围，则默认不限速内网ip
-                    elif not IpUtils.is_private_ip(session.get("address")) \
-                            and session.get("type") == "Video":
-                        total_bit_rate += int(session.get("bitrate") or 0)
 
         if total_bit_rate:
             # 开启智能限速计算上传限速

app/plugins/torrentremover/__init__.py

@@ -644,7 +644,7 @@ class TorrentRemover(_PluginBase):
             return None
         if self._torrentstates and torrent.state not in self._torrentstates:
             return None
-        if self._torrentcategorys and torrent.category not in self._torrentcategorys:
+        if self._torrentcategorys and (not torrent.category or torrent.category not in self._torrentcategorys):
             return None
         return {
             "id": torrent.hash,
@@ -731,20 +731,34 @@ class TorrentRemover(_PluginBase):
             remove_torrents.append(item)
         # 处理辅种
         if self._samedata and remove_torrents:
+            remove_ids = [t.get("id") for t in remove_torrents]
             remove_torrents_plus = []
             for remove_torrent in remove_torrents:
                 name = remove_torrent.get("name")
                 size = remove_torrent.get("size")
                 for torrent in torrents:
                     if downloader == "qbittorrent":
-                        item_plus = self.__get_qb_torrent(torrent)
+                        plus_id = torrent.hash
+                        plus_name = torrent.name
+                        plus_size = torrent.size
+                        plus_site = StringUtils.get_url_sld(torrent.tracker)
                     else:
-                        item_plus = self.__get_tr_torrent(torrent)
-                    if not item_plus:
-                        continue
-                    if item_plus.get("name") == name \
-                            and item_plus.get("size") == size \
-                            and item_plus.get("id") not in [t.get("id") for t in remove_torrents]:
-                        remove_torrents_plus.append(item_plus)
-            remove_torrents.extend(remove_torrents_plus)
+                        plus_id = torrent.hashString
+                        plus_name = torrent.name
+                        plus_size = torrent.total_size
+                        plus_site = torrent.trackers[0].get("sitename") if torrent.trackers else ""
+                    # 比对名称和大小
+                    if plus_name == name \
+                            and plus_size == size \
+                            and plus_id not in remove_ids:
+                        remove_torrents_plus.append(
+                            {
+                                "id": plus_id,
+                                "name": plus_name,
+                                "site": plus_site,
+                                "size": plus_size
+                            }
+                        )
+            if remove_torrents_plus:
+                remove_torrents.extend(remove_torrents_plus)
         return remove_torrents

app/scheduler.py

@@ -1,10 +1,12 @@
 import logging
 from datetime import datetime, timedelta
+from typing import List
 
 import pytz
 from apscheduler.executors.pool import ThreadPoolExecutor
 from apscheduler.schedulers.background import BackgroundScheduler
 
+from app import schemas
 from app.chain import ChainBase
 from app.chain.cookiecloud import CookieCloudChain
 from app.chain.mediaserver import MediaServerChain
@@ -40,57 +42,153 @@ class Scheduler(metaclass=Singleton):
     def __init__(self):
         # 数据库连接
         self._db = SessionFactory()
+        # 各服务的运行状态
+        self._jobs = {
+            "cookiecloud": {
+                "func": CookieCloudChain(self._db).process,
+                "running": False,
+            },
+            "mediaserver_sync": {
+                "func": MediaServerChain(self._db).sync,
+                "running": False,
+            },
+            "subscribe_tmdb": {
+                "func": SubscribeChain(self._db).check,
+                "running": False,
+            },
+            "subscribe_search": {
+                "func": SubscribeChain(self._db).search,
+                "running": False,
+            },
+            "subscribe_refresh": {
+                "func": SubscribeChain(self._db).refresh,
+                "running": False,
+            },
+            "transfer": {
+                "func": TransferChain(self._db).process,
+                "running": False,
+            }
+        }
+
         # 调试模式不启动定时服务
         if settings.DEV:
             return
+
         # CookieCloud定时同步
         if settings.COOKIECLOUD_INTERVAL:
-            self._scheduler.add_job(CookieCloudChain(self._db).process,
-                                    "interval",
-                                    minutes=settings.COOKIECLOUD_INTERVAL,
-                                    next_run_time=datetime.now(pytz.timezone(settings.TZ)) + timedelta(minutes=1),
-                                    name="同步CookieCloud站点")
+            self._scheduler.add_job(
+                self.start,
+                "interval",
+                id="cookiecloud",
+                name="同步CookieCloud站点",
+                minutes=settings.COOKIECLOUD_INTERVAL,
+                next_run_time=datetime.now(pytz.timezone(settings.TZ)) + timedelta(minutes=1),
+                kwargs={
+                    'job_id': 'cookiecloud'
+                }
+            )
 
         # 媒体服务器同步
         if settings.MEDIASERVER_SYNC_INTERVAL:
-            self._scheduler.add_job(MediaServerChain(self._db).sync, "interval",
-                                    hours=settings.MEDIASERVER_SYNC_INTERVAL,
-                                    next_run_time=datetime.now(pytz.timezone(settings.TZ)) + timedelta(minutes=5),
-                                    name="同步媒体服务器")
+            self._scheduler.add_job(
+                self.start,
+                "interval",
+                id="mediaserver_sync",
+                name="同步媒体服务器",
+                hours=settings.MEDIASERVER_SYNC_INTERVAL,
+                next_run_time=datetime.now(pytz.timezone(settings.TZ)) + timedelta(minutes=5),
+                kwargs={
+                    'job_id': 'mediaserver_sync'
+                }
+            )
 
         # 新增订阅时搜索（5分钟检查一次）
-        self._scheduler.add_job(SubscribeChain(self._db).search, "interval",
-                                minutes=5, kwargs={'state': 'N'})
+        self._scheduler.add_job(
+            self.start,
+            "interval",
+            minutes=5,
+            kwargs={
+                'job_id': 'subscribe_search',
+                'state': 'N'
+            }
+        )
 
         # 检查更新订阅TMDB数据（每隔6小时）
-        self._scheduler.add_job(SubscribeChain(self._db).check, "interval", hours=6)
+        self._scheduler.add_job(
+            self.start,
+            "interval",
+            id="subscribe_tmdb",
+            name="订阅元数据更新",
+            hours=6,
+            kwargs={
+                'job_id': 'subscribe_tmdb'
+            }
+        )
 
         # 订阅状态每隔24小时搜索一次
         if settings.SUBSCRIBE_SEARCH:
-            self._scheduler.add_job(SubscribeChain(self._db).search, "interval",
-                                    hours=24, kwargs={'state': 'R'}, name="订阅搜索")
+            self._scheduler.add_job(
+                self.start,
+                "interval",
+                id="subscribe_search",
+                name="订阅搜索",
+                hours=24,
+                kwargs={
+                    'job_id': 'subscribe_search',
+                    'state': 'R'
+                }
+            )
 
         if settings.SUBSCRIBE_MODE == "spider":
             # 站点首页种子定时刷新模式
             triggers = TimerUtils.random_scheduler(num_executions=30)
             for trigger in triggers:
-                self._scheduler.add_job(SubscribeChain(self._db).refresh, "cron",
-                                        hour=trigger.hour, minute=trigger.minute, name="订阅刷新")
+                self._scheduler.add_job(
+                    self.start,
+                    "cron",
+                    id=f"subscribe_refresh|{trigger.hour}:{trigger.minute}",
+                    name="订阅刷新",
+                    hour=trigger.hour,
+                    minute=trigger.minute,
+                    kwargs={
+                        'job_id': 'subscribe_refresh'
+                    })
         else:
             # RSS订阅模式
             if not settings.SUBSCRIBE_RSS_INTERVAL:
                 settings.SUBSCRIBE_RSS_INTERVAL = 30
             elif settings.SUBSCRIBE_RSS_INTERVAL < 5:
                 settings.SUBSCRIBE_RSS_INTERVAL = 5
-            self._scheduler.add_job(SubscribeChain(self._db).refresh, "interval",
-                                    minutes=settings.SUBSCRIBE_RSS_INTERVAL, name="订阅刷新")
+            self._scheduler.add_job(
+                self.start,
+                "interval",
+                id="subscribe_refresh",
+                name="RSS订阅刷新",
+                minutes=settings.SUBSCRIBE_RSS_INTERVAL,
+                kwargs={
+                    'job_id': 'subscribe_refresh'
+                }
+            )
 
         # 下载器文件转移（每5分钟）
         if settings.DOWNLOADER_MONITOR:
-            self._scheduler.add_job(TransferChain(self._db).process, "interval", minutes=5, name="下载文件整理")
+            self._scheduler.add_job(
+                self.start,
+                "interval",
+                id="transfer",
+                name="下载文件整理",
+                minutes=5,
+                kwargs={
+                    'job_id': 'transfer'
+                }
+            )
 
         # 公共定时服务
-        self._scheduler.add_job(SchedulerChain(self._db).scheduler_job, "interval", minutes=10)
+        self._scheduler.add_job(
+            SchedulerChain(self._db).scheduler_job,
+            "interval",
+            minutes=10
+        )
 
         # 打印服务
         logger.debug(self._scheduler.print_jobs())
@@ -98,11 +196,54 @@ class Scheduler(metaclass=Singleton):
         # 启动定时服务
         self._scheduler.start()
 
-    def list(self):
+    def start(self, job_id: str, *args, **kwargs):
+        """
+        启动定时服务
+        """
+        # 处理job_id格式
+        job = self._jobs.get(job_id)
+        if not job:
+            return
+        if job.get("running"):
+            logger.warning(f"定时任务 {job_id} 正在运行 ...")
+            return
+        self._jobs[job_id]["running"] = True
+        try:
+            job["func"](*args, **kwargs)
+        except Exception as e:
+            logger.error(f"定时任务 {job_id} 执行失败：{e}")
+        self._jobs[job_id]["running"] = False
+
+    def list(self) -> List[schemas.ScheduleInfo]:
         """
         当前所有任务
         """
-        return self._scheduler.get_jobs()
+        # 返回计时任务
+        schedulers = []
+        # 去重
+        added = []
+        jobs = self._scheduler.get_jobs()
+        # 按照下次运行时间排序
+        jobs.sort(key=lambda x: x.next_run_time)
+        for job in jobs:
+            if job.name not in added:
+                added.append(job.name)
+            else:
+                continue
+            job_id = job.id.split("|")[0]
+            if not self._jobs.get(job_id):
+                continue
+            # 任务状态
+            status = "正在运行" if self._jobs[job_id].get("running") else "等待"
+            # 下次运行时间
+            next_run = TimerUtils.time_difference(job.next_run_time)
+            schedulers.append(schemas.ScheduleInfo(
+                id=job_id,
+                name=job.name,
+                status=status,
+                next_run=next_run
+            ))
+        return schedulers
 
     def stop(self):
         """

app/schemas/message.py

@@ -51,3 +51,5 @@ class NotificationSwitch(BaseModel):
     telegram: Optional[bool] = False
     # Slack开关
     slack: Optional[bool] = False
+    # SynologyChat开关
+    synologychat: Optional[bool] = False

app/schemas/transfer.py

@@ -35,6 +35,8 @@ class TransferInfo(BaseModel):
     """
     文件转移结果信息
     """
+    # 是否成功标志
+    success: bool = True
     # 转移⼁路径
     path: Optional[Path] = None
     # 转移后路径

app/schemas/types.py

@@ -48,7 +48,7 @@ class SystemConfigKey(Enum):
     UserInstalledPlugins = "UserInstalledPlugins"
     # 搜索结果
     SearchResults = "SearchResults"
-    # 索引站点范围
+    # 搜索站点范围
     IndexerSites = "IndexerSites"
     # 订阅站点范围
     RssSites = "RssSites"
@@ -60,10 +60,14 @@ class SystemConfigKey(Enum):
     CustomReleaseGroups = "CustomReleaseGroups"
     # 自定义识别词
     CustomIdentifiers = "CustomIdentifiers"
-    # 过滤规则
-    FilterRules = "FilterRules"
+    # 搜索优先级规则
+    SearchFilterRules = "SearchFilterRules"
+    # 订阅优先级规则
+    SubscribeFilterRules = "SubscribeFilterRules"
     # 洗版规则
-    FilterRules2 = "FilterRules2"
+    BestVersionFilterRules = "BestVersionFilterRules"
+    # 默认过滤规则
+    DefaultFilterRules = "DefaultFilterRules"
     # 转移屏蔽词
     TransferExcludeWords = "TransferExcludeWords"
 
@@ -105,3 +109,4 @@ class MessageChannel(Enum):
     Wechat = "微信"
     Telegram = "Telegram"
     Slack = "Slack"
+    SynologyChat = "SynologyChat"

app/utils/http.py

@@ -172,39 +172,3 @@ class RequestUtils:
                 cookiesList.append(cookies)
             return cookiesList
         return cookie_dict
-
-
-class WebUtils:
-    @staticmethod
-    def get_location(ip: str):
-        """
-        https://api.mir6.com/api/ip
-        {
-            "code": 200,
-            "msg": "success",
-            "data": {
-                "ip": "240e:97c:2f:1::5c",
-                "dec": "47925092370311863177116789888333643868",
-                "country": "中国",
-                "countryCode": "CN",
-                "province": "广东省",
-                "city": "广州市",
-                "districts": "",
-                "idc": "",
-                "isp": "中国电信",
-                "net": "数据中心",
-                "zipcode": "510000",
-                "areacode": "020",
-                "protocol": "IPv6",
-                "location": "中国[CN] 广东省 广州市",
-                "myip": "125.89.7.89",
-                "time": "2023-09-01 17:28:23"
-            }
-        }
-        """
-        try:
-            r = RequestUtils().get_res(f"https://api.mir6.com/api/ip?ip={ip}&type=json")
-            if r:
-                return r.json().get("data", {}).get("location") or ''
-        except Exception as err:
-            return str(err)

app/utils/site.py

@@ -17,17 +17,45 @@ class SiteUtils:
         if html.xpath("//input[@type='password']"):
             return False
         # 是否存在登出和用户面板等链接
-        xpaths = ['//a[contains(@href, "logout")'
-                  ' or contains(@data-url, "logout")'
-                  ' or contains(@href, "mybonus") '
-                  ' or contains(@onclick, "logout")'
-                  ' or contains(@href, "usercp")]',
-                  '//form[contains(@action, "logout")]']
+        xpaths = [
+            '//a[contains(@href, "logout")'
+            ' or contains(@data-url, "logout")'
+            ' or contains(@href, "mybonus") '
+            ' or contains(@onclick, "logout")'
+            ' or contains(@href, "usercp")]',
+            '//form[contains(@action, "logout")]',
+            '//div[@class="user-info-side"]'
+        ]
         for xpath in xpaths:
             if html.xpath(xpath):
                 return True
-        user_info_div = html.xpath('//div[@class="user-info-side"]')
-        if user_info_div:
-            return True
-
         return False
+
+    @classmethod
+    def is_checkin(cls, html_text: str) -> bool:
+        """
+        判断站点是否已经签到
+        :return True已签到 False未签到
+        """
+        html = etree.HTML(html_text)
+        if not html:
+            return False
+        # 站点签到支持的识别XPATH
+        xpaths = [
+            '//a[@id="signed"]',
+            '//a[contains(@href, "attendance")]',
+            '//a[contains(text(), "签到")]',
+            '//a/b[contains(text(), "签 到")]',
+            '//span[@id="sign_in"]/a',
+            '//a[contains(@href, "addbonus")]',
+            '//input[@class="dt_button"][contains(@value, "打卡")]',
+            '//a[contains(@href, "sign_in")]',
+            '//a[contains(@onclick, "do_signin")]',
+            '//a[@id="do-attendance"]',
+            '//shark-icon-button[@href="attendance.php"]'
+        ]
+        for xpath in xpaths:
+            if html.xpath(xpath):
+                return False
+
+        return True

app/utils/system.py

@@ -106,7 +106,7 @@ class SystemUtils:
 
         if directory.is_file():
             return [directory]
-            
+
         if not min_filesize:
             min_filesize = 0
 
@@ -122,6 +122,36 @@ class SystemUtils:
 
         return files
 
+    @staticmethod
+    def exits_files(directory: Path, extensions: list, min_filesize: int = 0) -> bool:
+        """
+        判断目录下是否存在指定扩展名的文件
+        :return True存在 False不存在
+        """
+
+        if not min_filesize:
+            min_filesize = 0
+
+        if not directory.exists():
+            return False
+
+        if directory.is_file():
+            return True
+
+        if not min_filesize:
+            min_filesize = 0
+
+        pattern = r".*(" + "|".join(extensions) + ")$"
+
+        # 遍历目录及子目录
+        for path in directory.rglob('**/*'):
+            if path.is_file() \
+                    and re.match(pattern, path.name, re.IGNORECASE) \
+                    and path.stat().st_size >= min_filesize * 1024 * 1024:
+                return True
+
+        return False
+
     @staticmethod
     def list_sub_files(directory: Path, extensions: list) -> List[Path]:
         """
@@ -313,9 +343,9 @@ class SystemUtils:
             # 获取当前容器的 ID
             with open('/proc/self/mountinfo', 'r') as f:
                 data = f.read()
-                index_resolv_conf = data.find("resolv.conf")
+                index_resolv_conf = data.find("/sys/fs/cgroup/devices")
                 if index_resolv_conf != -1:
-                    index_second_slash = data.rfind("/", 0, index_resolv_conf)
+                    index_second_slash = data.rfind(" ", 0, index_resolv_conf)
                     index_first_slash = data.rfind("/", 0, index_second_slash) + 1
                     container_id = data[index_first_slash:index_second_slash]
             if not container_id:

app/utils/web.py

@@ -0,0 +1,56 @@
+from typing import Optional
+
+from app.utils.http import RequestUtils
+
+
+class WebUtils:
+    @staticmethod
+    def get_location(ip: str):
+        """
+        https://api.mir6.com/api/ip
+        {
+            "code": 200,
+            "msg": "success",
+            "data": {
+                "ip": "240e:97c:2f:1::5c",
+                "dec": "47925092370311863177116789888333643868",
+                "country": "中国",
+                "countryCode": "CN",
+                "province": "广东省",
+                "city": "广州市",
+                "districts": "",
+                "idc": "",
+                "isp": "中国电信",
+                "net": "数据中心",
+                "zipcode": "510000",
+                "areacode": "020",
+                "protocol": "IPv6",
+                "location": "中国[CN] 广东省 广州市",
+                "myip": "125.89.7.89",
+                "time": "2023-09-01 17:28:23"
+            }
+        }
+        """
+        try:
+            r = RequestUtils().get_res(f"https://api.mir6.com/api/ip?ip={ip}&type=json")
+            if r:
+                return r.json().get("data", {}).get("location") or ''
+        except Exception as err:
+            return str(err)
+
+    @staticmethod
+    def get_bing_wallpaper() -> Optional[str]:
+        """
+        获取Bing每日壁纸
+        """
+        url = "https://cn.bing.com/HPImageArchive.aspx?format=js&idx=0&n=1"
+        resp = RequestUtils(timeout=5).get_res(url)
+        if resp and resp.status_code == 200:
+            try:
+                result = resp.json()
+                if isinstance(result, dict):
+                    for image in result.get('images') or []:
+                        return f"https://cn.bing.com{image.get('url')}" if 'url' in image else ''
+            except Exception as err:
+                print(str(err))
+        return None

version.py

@@ -1 +1 @@
-APP_VERSION = 'v1.2.0'
+APP_VERSION = 'v1.2.5'