更新 version.py

fix(dependencies): pin python-115 version

app/api/endpoints/subscribe.py

@@ -8,6 +8,7 @@ from app import schemas
 from app.chain.subscribe import SubscribeChain
 from app.core.config import settings
 from app.core.context import MediaInfo
+from app.core.event import eventmanager
 from app.core.metainfo import MetaInfo
 from app.core.security import verify_token, verify_apitoken
 from app.db import get_db
@@ -17,7 +18,7 @@ from app.db.models.user import User
 from app.db.user_oper import get_current_active_user
 from app.helper.subscribe import SubscribeHelper
 from app.scheduler import Scheduler
-from app.schemas.types import MediaType
+from app.schemas.types import MediaType, EventType
 
 router = APIRouter()
 
@@ -207,8 +208,9 @@ def reset_subscribes(
     subscribe = Subscribe.get(db, subid)
     if subscribe:
         subscribe.update(db, {
-            "note": "",
-            "lack_episode": subscribe.total_episode
+            "note": [],
+            "lack_episode": subscribe.total_episode,
+            "state": "R"
         })
         return schemas.Response(success=True)
     return schemas.Response(success=False, message="订阅不存在")
@@ -273,17 +275,27 @@ def delete_subscribe_by_mediaid(
     """
     根据TMDBID或豆瓣ID删除订阅 tmdb:/douban:
     """
+    delete_subscribes = []
     if mediaid.startswith("tmdb:"):
         tmdbid = mediaid[5:]
         if not tmdbid or not str(tmdbid).isdigit():
             return schemas.Response(success=False)
-        Subscribe().delete_by_tmdbid(db, int(tmdbid), season)
+        subscribes = Subscribe().get_by_tmdbid(db, int(tmdbid), season)
+        delete_subscribes.extend(subscribes)
     elif mediaid.startswith("douban:"):
         doubanid = mediaid[7:]
         if not doubanid:
             return schemas.Response(success=False)
-        Subscribe().delete_by_doubanid(db, doubanid)
-
+        subscribe = Subscribe().get_by_doubanid(db, doubanid)
+        if subscribe:
+            delete_subscribes.append(subscribe)
+    for subscribe in delete_subscribes:
+        Subscribe().delete(db, subscribe.id)
+        # 发送事件
+        eventmanager.send_event(EventType.SubscribeDeleted, {
+            "subscribe_id": subscribe.id,
+            "subscribe_info": subscribe.to_dict()
+        })
     return schemas.Response(success=True)
 
 
@@ -506,9 +518,14 @@ def delete_subscribe(
     subscribe = Subscribe.get(db, subscribe_id)
     if subscribe:
         subscribe.delete(db, subscribe_id)
-    # 统计订阅
-    SubscribeHelper().sub_done_async({
-        "tmdbid": subscribe.tmdbid,
-        "doubanid": subscribe.doubanid
-    })
+        # 发送事件
+        eventmanager.send_event(EventType.SubscribeDeleted, {
+            "subscribe_id": subscribe_id,
+            "subscribe_info": subscribe.to_dict()
+        })
+        # 统计订阅
+        SubscribeHelper().sub_done_async({
+            "tmdbid": subscribe.tmdbid,
+            "doubanid": subscribe.doubanid
+        })
     return schemas.Response(success=True)

app/api/endpoints/transfer.py

@@ -1,8 +1,7 @@
 from pathlib import Path
-from typing import Any, Optional
+from typing import Any
 
 from fastapi import APIRouter, Depends
-from pydantic import BaseModel
 from sqlalchemy.orm import Session
 
 from app import schemas
@@ -14,50 +13,11 @@ from app.core.security import verify_token, verify_apitoken
 from app.db import get_db
 from app.db.models.transferhistory import TransferHistory
 from app.db.user_oper import get_current_active_superuser
-from app.schemas import MediaType, FileItem
+from app.schemas import MediaType, FileItem, ManualTransferItem
 
 router = APIRouter()
 
 
-class ManualTransferItem(BaseModel):
-    # 文件项
-    fileitem: FileItem = None
-    # 日志ID
-    logid: Optional[int] = None
-    # 目标存储
-    target_storage: Optional[str] = None
-    # 目标路径
-    target_path: Optional[str] = None
-    # TMDB ID
-    tmdbid: Optional[int] = None
-    # 豆瓣ID
-    doubanid: Optional[str] = None
-    # 类型
-    type_name: Optional[str] = None
-    # 季号
-    season: Optional[int] = None
-    # 整理方式
-    transfer_type: Optional[str] = None
-    # 自定义格式
-    episode_format: Optional[str] = None
-    # 指定集数
-    episode_detail: Optional[str] = None
-    # 指定PART
-    episode_part: Optional[str] = None
-    # 集数偏移
-    episode_offset: Optional[str] = None
-    # 最小文件大小
-    min_filesize: Optional[int] = 0
-    # 刮削
-    scrape: bool = False
-    # 媒体库类型子目录
-    library_type_folder: Optional[bool] = None
-    # 媒体库类别子目录
-    library_category_folder: Optional[bool] = None
-    # 复用历史识别信息
-    from_history: Optional[bool] = False
-
-
 @router.get("/name", summary="查询整理后的名称", response_model=schemas.Response)
 def query_name(path: str, filetype: str,
                _: schemas.TokenPayload = Depends(verify_token)) -> Any:

app/chain/download.py

@@ -227,7 +227,7 @@ class DownloadChain(ChainBase):
         # 发送资源下载事件，允许外部拦截下载
         event_data = ResourceDownloadEventData(
             context=context,
-            episodes=episodes,
+            episodes=episodes or context.meta_info.episode_list,
             channel=channel,
             origin=source,
             downloader=downloader,
@@ -345,7 +345,8 @@ class DownloadChain(ChainBase):
                 username=username,
                 channel=channel.value if channel else None,
                 date=time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),
-                media_category=media_category
+                media_category=media_category,
+                note={"source": source}
             )
 
             # 登记下载文件
@@ -383,7 +384,8 @@ class DownloadChain(ChainBase):
                 "context": context,
                 "username": username,
                 "downloader": _downloader,
-                "episodes": episodes
+                "episodes": episodes or _meta.episode_list,
+                "source": source
             })
         else:
             # 下载失败
@@ -489,7 +491,8 @@ class DownloadChain(ChainBase):
         logger.debug(f"Initial contexts: {len(contexts)} items, Downloader: {downloader}")
         event_data = ResourceSelectionEventData(
             contexts=contexts,
-            downloader=downloader
+            downloader=downloader,
+            origin=source
         )
         event = eventmanager.send_event(ChainEventType.ResourceSelection, event_data)
         # 如果事件修改了上下文数据，使用更新后的数据

app/chain/site.py

@@ -87,7 +87,8 @@ class SiteChain(ChainBase):
                         link=site.get("url")
                     ))
             # 低分享率警告
-            if userdata.ratio and float(userdata.ratio) < 1:
+            if userdata.ratio and float(userdata.ratio) < 1 and not bool(
+                    re.search(r"(贵宾|VIP?)", userdata.user_level, re.IGNORECASE)):
                 self.post_message(Notification(
                     mtype=NotificationType.SiteMessage,
                     title=f"【站点分享率低预警】",

app/chain/subscribe.py

@@ -1,7 +1,8 @@
 import copy
+import json
 import random
-import time
 import threading
+import time
 from datetime import datetime
 from typing import Dict, List, Optional, Union, Tuple
 
@@ -287,55 +288,13 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                             f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}')
                         continue
 
-                    # 非洗版状态
-                    if not subscribe.best_version:
-                        # 每季总集数
-                        totals = {}
-                        if subscribe.season and subscribe.total_episode:
-                            totals = {
-                                subscribe.season: subscribe.total_episode
-                            }
-                        # 查询媒体库缺失的媒体信息
-                        exist_flag, no_exists = self.downloadchain.get_no_exists_info(
-                            meta=meta,
-                            mediainfo=mediainfo,
-                            totals=totals
-                        )
-                    else:
-                        # 洗版状态
-                        exist_flag = False
-                        if meta.type == MediaType.TV:
-                            no_exists = {
-                                mediakey: {
-                                    subscribe.season: NotExistMediaInfo(
-                                        season=subscribe.season,
-                                        episodes=[],
-                                        total_episode=subscribe.total_episode,
-                                        start_episode=subscribe.start_episode or 1)
-                                }
-                            }
-                        else:
-                            no_exists = {}
-
-                    # 已存在
+                    # 如果媒体已存在或已下载完毕，跳过当前订阅处理
+                    exist_flag, no_exists = self.check_and_handle_existing_media(subscribe=subscribe, meta=meta,
+                                                                                 mediainfo=mediainfo,
+                                                                                 mediakey=mediakey)
                     if exist_flag:
-                        logger.info(f'{mediainfo.title_year} 媒体库中已存在')
-                        self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo, force=True)
                         continue
 
-                    # 电视剧订阅处理缺失集
-                    if meta.type == MediaType.TV:
-                        # 实际缺失集与订阅开始结束集范围进行整合，同时剔除已下载的集数
-                        no_exists = self.__get_subscribe_no_exits(
-                            subscribe_name=f'{subscribe.name} {meta.season}',
-                            no_exists=no_exists,
-                            mediakey=mediakey,
-                            begin_season=meta.begin_season,
-                            total_episode=subscribe.total_episode,
-                            start_episode=subscribe.start_episode,
-                            downloaded_episodes=self.__get_downloaded_episodes(subscribe)
-                        )
-
                     # 站点范围
                     sites = self.get_sub_sites(subscribe)
 
@@ -399,15 +358,19 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                         save_path=subscribe.save_path,
                         media_category=subscribe.media_category,
                         downloader=subscribe.downloader,
-                        source="Subscribe"
+                        source=self.get_subscribe_source_keyword(subscribe)
                     )
 
+                    # 同步外部修改，更新订阅信息
+                    subscribe = self.subscribeoper.get(subscribe.id)
+
                     # 判断是否应完成订阅
-                    self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo,
-                                                 downloads=downloads, lefts=lefts)
+                    if subscribe:
+                        self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo,
+                                                     downloads=downloads, lefts=lefts)
                 finally:
                     # 如果状态为N则更新为R
-                    if subscribe.state == 'N':
+                    if subscribe and subscribe.state == 'N':
                         self.subscribeoper.update(subscribe.id, {'state': 'R'})
 
             # 手动触发时发送系统消息
@@ -432,15 +395,17 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
             return
         # 当前下载资源的优先级
         priority = max([item.torrent_info.pri_order for item in downloads])
+        # 订阅存在待定策略，不管是否已完成，均需更新订阅信息
+        self.subscribeoper.update(subscribe.id, {
+            "current_priority": priority,
+            "last_update": datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        })
         if priority == 100:
             # 洗版完成
-            self.__finish_subscribe(subscribe=subscribe, meta=meta, mediainfo=mediainfo, bestversion=True)
+            self.__finish_subscribe(subscribe=subscribe, meta=meta, mediainfo=mediainfo)
         else:
             # 正在洗版，更新资源优先级
             logger.info(f'{mediainfo.title_year} 正在洗版，更新资源优先级为 {priority}')
-            self.subscribeoper.update(subscribe.id, {
-                "current_priority": priority
-            })
 
     def finish_subscribe_or_not(self, subscribe: Subscribe, meta: MetaInfo, mediainfo: MediaInfo,
                                 downloads: List[Context] = None,
@@ -454,29 +419,27 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         no_lefts = not lefts or not lefts.get(mediakey)
         # 是否完成订阅
         if not subscribe.best_version:
-            # 非洗板
+            # 订阅存在待定策略，不管是否已完成，均需更新订阅信息
+            # 更新订阅已下载信息
+            self.__update_subscribe_note(subscribe=subscribe, downloads=downloads)
+            # 更新订阅剩余集数和时间
+            self.__update_lack_episodes(lefts=lefts, subscribe=subscribe, mediainfo=mediainfo,
+                                        update_date=bool(downloads))
+            # 判断是否需要完成订阅
             if ((no_lefts and meta.type == MediaType.TV)
                     or (downloads and meta.type == MediaType.MOVIE)
                     or force):
-                # 完成订阅
                 self.__finish_subscribe(subscribe=subscribe, meta=meta, mediainfo=mediainfo)
-            elif downloads and meta.type == MediaType.TV:
-                # 电视剧更新已下载集数
-                self.__update_subscribe_note(subscribe=subscribe, downloads=downloads)
-                # 更新订阅剩余集数和时间
-                self.__update_lack_episodes(lefts=lefts, subscribe=subscribe,
-                                            mediainfo=mediainfo, update_date=True)
             else:
                 # 未下载到内容且不完整
                 logger.info(f'{mediainfo.title_year} 未下载完整，继续订阅 ...')
-                if meta.type == MediaType.TV:
-                    # 更新订阅剩余集数
-                    self.__update_lack_episodes(lefts=lefts, subscribe=subscribe,
-                                                mediainfo=mediainfo, update_date=False)
         elif downloads:
-            # 洗板，下载到了内容，更新资源优先级
+            # 洗版下载到了内容，更新资源优先级
             self.update_subscribe_priority(subscribe=subscribe, meta=meta,
                                            mediainfo=mediainfo, downloads=downloads)
+        elif subscribe.current_priority == 100:
+            # 洗版完成
+            self.__finish_subscribe(subscribe=subscribe, meta=meta, mediainfo=mediainfo)
         else:
             # 洗版，未下载到内容
             logger.info(f'{mediainfo.title_year} 继续洗版 ...')
@@ -579,55 +542,14 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                     logger.warn(
                         f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}')
                     continue
-                # 非洗版
-                if not subscribe.best_version:
-                    # 每季总集数
-                    totals = {}
-                    if subscribe.season and subscribe.total_episode:
-                        totals = {
-                            subscribe.season: subscribe.total_episode
-                        }
-                    # 查询缺失的媒体信息
-                    exist_flag, no_exists = self.downloadchain.get_no_exists_info(
-                        meta=meta,
-                        mediainfo=mediainfo,
-                        totals=totals
-                    )
-                else:
-                    # 洗版
-                    exist_flag = False
-                    if meta.type == MediaType.TV:
-                        no_exists = {
-                            mediakey: {
-                                subscribe.season: NotExistMediaInfo(
-                                    season=subscribe.season,
-                                    episodes=[],
-                                    total_episode=subscribe.total_episode,
-                                    start_episode=subscribe.start_episode or 1)
-                            }
-                        }
-                    else:
-                        no_exists = {}
 
-                # 已存在
+                # 如果媒体已存在或已下载完毕，跳过当前订阅处理
+                exist_flag, no_exists = self.check_and_handle_existing_media(subscribe=subscribe, meta=meta,
+                                                                             mediainfo=mediainfo,
+                                                                             mediakey=mediakey)
                 if exist_flag:
-                    logger.info(f'{mediainfo.title_year} 媒体库中已存在')
-                    self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo, force=True)
                     continue
 
-                # 电视剧订阅
-                if meta.type == MediaType.TV:
-                    # 整合实际缺失集与订阅开始集结束集，同时剔除已下载的集数
-                    no_exists = self.__get_subscribe_no_exits(
-                        subscribe_name=f'{subscribe.name} {meta.season}',
-                        no_exists=no_exists,
-                        mediakey=mediakey,
-                        begin_season=meta.begin_season,
-                        total_episode=subscribe.total_episode,
-                        start_episode=subscribe.start_episode,
-                        downloaded_episodes=self.__get_downloaded_episodes(subscribe)
-                    )
-
                 # 遍历缓存种子
                 _match_context = []
                 for domain, contexts in torrents.items():
@@ -791,10 +713,16 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                                                                      save_path=subscribe.save_path,
                                                                      media_category=subscribe.media_category,
                                                                      downloader=subscribe.downloader,
-                                                                     source="Subscribe")
+                                                                     source=self.get_subscribe_source_keyword(subscribe)
+                                                                     )
+
+                # 同步外部修改，更新订阅信息
+                subscribe = self.subscribeoper.get(subscribe.id)
+
                 # 判断是否要完成订阅
-                self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo,
-                                             downloads=downloads, lefts=lefts)
+                if subscribe:
+                    self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo,
+                                                 downloads=downloads, lefts=lefts)
             logger.debug(f"match Lock released at {datetime.now()}")
 
     def check(self):
@@ -856,7 +784,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
 
     def __update_subscribe_note(self, subscribe: Subscribe, downloads: List[Context]):
         """
-        更新已下载集数到note字段
+        更新已下载信息到note字段
         """
         # 查询现有Note
         if not downloads:
@@ -867,71 +795,85 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         for context in downloads:
             meta = context.meta_info
             mediainfo = context.media_info
-            if mediainfo.type != MediaType.TV:
-                continue
             if subscribe.tmdbid and mediainfo.tmdb_id \
                     and mediainfo.tmdb_id != subscribe.tmdbid:
                 continue
             if subscribe.doubanid and mediainfo.douban_id \
                     and mediainfo.douban_id != subscribe.doubanid:
                 continue
-            episodes = meta.episode_list
-            if not episodes:
+            items = []
+            if mediainfo.type == MediaType.TV:
+                # 电视剧有集数，使用 episode_list
+                items = meta.episode_list
+            elif mediainfo.type == MediaType.MOVIE:
+                # 电影只有一个条目，设置为 [1]
+                items = [1]
+            if not items:
                 continue
-            # 合并已下载集
-            note = list(set(note).union(set(episodes)))
-            # 更新订阅
+            # 合并已下载的集数或电影项（去重）
+            note = list(set(note).union(set(items)))
+        # 更新订阅
+        if note:
             self.subscribeoper.update(subscribe.id, {
                 "note": note
             })
 
     @staticmethod
-    def __get_downloaded_episodes(subscribe: Subscribe) -> List[int]:
+    def __get_downloaded(subscribe: Subscribe) -> List[int]:
         """
-        获取已下载过的集数
+        获取已下载过的集数或电影
         """
-        if not subscribe.note:
+        if subscribe.best_version:
             return []
-        if subscribe.type != MediaType.TV.value:
+        note = subscribe.note or []
+        if not note:
             return []
-        episodes = subscribe.note or []
-        logger.info(f'订阅 {subscribe.name} 第{subscribe.season}季 已下载集数：{episodes}')
-        return episodes
+        # 针对 TV 类型，返回已下载的集数
+        if subscribe.type == MediaType.TV.value:
+            logger.info(f'订阅 {subscribe.name} 第{subscribe.season}季 已下载集数：{note}')
+            return note
+        # 针对 Movie 类型，直接返回已下载的电影
+        if subscribe.type == MediaType.MOVIE.value:
+            logger.info(f'订阅 {subscribe.name} 已下载内容：{note}')
+            return note
+        return []
 
     def __update_lack_episodes(self, lefts: Dict[Union[int, str], Dict[int, NotExistMediaInfo]],
                                subscribe: Subscribe,
                                mediainfo: MediaInfo,
                                update_date: bool = False):
         """
-        更新订阅剩余集数
+        更新订阅剩余集数及时间
         """
-        if not lefts:
-            return
-        mediakey = subscribe.tmdbid or subscribe.doubanid
-        left_seasons = lefts.get(mediakey)
-        if left_seasons:
-            for season_info in left_seasons.values():
-                season = season_info.season
-                if season == subscribe.season:
-                    left_episodes = season_info.episodes
-                    if not left_episodes:
-                        lack_episode = season_info.total_episode
-                    else:
-                        lack_episode = len(left_episodes)
-                    logger.info(f'{mediainfo.title_year} 季 {season} 更新缺失集数为{lack_episode} ...')
-                    if update_date:
-                        # 同时更新最后时间
-                        self.subscribeoper.update(subscribe.id, {
-                            "lack_episode": lack_episode,
-                            "last_update": datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-                        })
-                    else:
-                        self.subscribeoper.update(subscribe.id, {
-                            "lack_episode": lack_episode
-                        })
+        update_data = {}
+        if update_date:
+            update_data["last_update"] = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        if subscribe.type == MediaType.TV.value:
+            if not lefts:
+                # 如果 lefts 为空，表示没有缺失集数，直接设置 lack_episode 为 0
+                lack_episode = 0
+                logger.info(f'{mediainfo.title_year} 没有缺失集数，直接更新为 0 ...')
+            else:
+                mediakey = subscribe.tmdbid or subscribe.doubanid
+                left_seasons = lefts.get(mediakey)
+                lack_episode = 0
+                if left_seasons:
+                    for season_info in left_seasons.values():
+                        season = season_info.season
+                        if season == subscribe.season:
+                            left_episodes = season_info.episodes
+                            if not left_episodes:
+                                lack_episode = season_info.total_episode
+                            else:
+                                lack_episode = len(left_episodes)
+                            logger.info(f"{mediainfo.title_year} 季 {season} 更新缺失集数为{lack_episode} ...")
+                            break
+            update_data["lack_episode"] = lack_episode
+        # 更新数据库
+        if update_data:
+            self.subscribeoper.update(subscribe.id, update_data)
 
-    def __finish_subscribe(self, subscribe: Subscribe, mediainfo: MediaInfo,
-                           meta: MetaBase, bestversion: bool = False):
+    def __finish_subscribe(self, subscribe: Subscribe, mediainfo: MediaInfo, meta: MetaBase):
         """
         完成订阅
         """
@@ -939,9 +881,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         if subscribe.state == "P":
             return
         # 完成订阅
-        msgstr = "订阅"
-        if bestversion:
-            msgstr = "洗版"
+        msgstr = "订阅" if not subscribe.best_version else "洗版"
         logger.info(f'{mediainfo.title_year} 完成{msgstr}')
         # 新增订阅历史
         self.subscribeoper.add_history(**subscribe.to_dict())
@@ -1037,7 +977,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                                  total_episode: int,
                                  start_episode: int,
                                  downloaded_episodes: List[int] = None
-                                 ) -> Dict[Union[int, str], Dict[int, NotExistMediaInfo]]:
+                                 ) -> Tuple[bool, Dict[Union[int, str], Dict[int, NotExistMediaInfo]]]:
         """
         根据订阅开始集数和总集数，结合TMDB信息计算当前订阅的缺失集数
         :param subscribe_name: 订阅名称
@@ -1050,7 +990,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         """
         # 使用订阅的总集数和开始集数替换no_exists
         if not no_exists or not no_exists.get(mediakey):
-            return no_exists
+            return False, no_exists
         no_exists_item = no_exists.get(mediakey)
         if total_episode or start_episode:
             logger.info(f'订阅 {subscribe_name} 设定的开始集数：{start_episode}、总集数：{total_episode}')
@@ -1075,7 +1015,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                     if not start_episode \
                             and not total_episode:
                         # 无需调整
-                        return no_exists
+                        return False, no_exists
                     if not start_episode:
                         # 没有自定义开始集
                         start_episode = start
@@ -1110,25 +1050,32 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                     episode_list = list(range(start, total + 1))
                 # 更新剧集列表
                 episodes = list(set(episode_list).difference(set(downloaded_episodes)))
+                # 如果存在已下载剧集，则差集为空时，说明所有均已存在
+                if not episodes:
+                    return True, {}
                 # 更新集合
                 no_exists[mediakey][begin_season] = NotExistMediaInfo(
                     season=begin_season,
                     episodes=episodes,
                     total_episode=total,
-                    start_episode=start
+                    start_episode=start,
                 )
             else:
                 # 开始集数
                 start = start_episode or 1
-                # 不存在的季
+                # 更新剧集列表
+                episodes = list(set(range(start, total_episode + 1)).difference(set(downloaded_episodes)))
+                # 如果存在已下载剧集，则差集为空时，说明所有均已存在
+                if not episodes:
+                    return True, {}
                 no_exists[mediakey][begin_season] = NotExistMediaInfo(
                     season=begin_season,
-                    episodes=list(set(range(start, total_episode + 1)).difference(set(downloaded_episodes))),
+                    episodes=episodes,
                     total_episode=total_episode,
-                    start_episode=start
+                    start_episode=start,
                 )
         logger.info(f'订阅 {subscribe_name} 缺失剧集数更新为：{no_exists}')
-        return no_exists
+        return False, no_exists
 
     @eventmanager.register(EventType.SiteDeleted)
     def remove_site(self, event: Event):
@@ -1148,7 +1095,7 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
                 if not subscribe.sites:
                     continue
                 self.subscribeoper.update(subscribe.id, {
-                    "sites": ""
+                    "sites": []
                 })
             return
         # 从选中的rss站点中移除
@@ -1317,6 +1264,90 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         subscribe_info.episodes = episodes
         return subscribe_info
 
+    def check_and_handle_existing_media(self, subscribe: Subscribe, meta: MetaInfo,
+                                        mediainfo: MediaInfo, mediakey: str):
+        """
+        检查媒体是否已经存在，并根据情况执行相应的操作
+        1. 查询缺失的媒体信息
+        2. 判断是否已经下载完毕
+        3. 根据媒体类型（电视剧或电影）执行不同的处理
+
+        :param subscribe: 订阅信息对象
+        :param meta: 媒体元数据
+        :param mediainfo: 媒体信息
+        :param mediakey: 媒体标识符
+        :return:
+            - exist_flag (bool): 布尔值，表示媒体是否已经完全下载或已存在
+            - no_exists (dict): 缺失的媒体信息，包含缺失的集数或其他相关信息
+        """
+        # 非洗版
+        if not subscribe.best_version:
+            # 每季总集数
+            totals = {}
+            if subscribe.season and subscribe.total_episode:
+                totals = {
+                    subscribe.season: subscribe.total_episode
+                }
+            # 查询媒体库缺失的媒体信息
+            exist_flag, no_exists = self.downloadchain.get_no_exists_info(
+                meta=meta,
+                mediainfo=mediainfo,
+                totals=totals
+            )
+        else:
+            # 洗版，如果已经满足了优先级，则认为已经洗版完成
+            if subscribe.current_priority == 100:
+                exist_flag = True
+                no_exists = {}
+            else:
+                exist_flag = False
+                if meta.type == MediaType.TV:
+                    # 对于电视剧，构造缺失的媒体信息
+                    no_exists = {
+                        mediakey: {
+                            subscribe.season: NotExistMediaInfo(
+                                season=subscribe.season,
+                                episodes=[],
+                                total_episode=subscribe.total_episode,
+                                start_episode=subscribe.start_episode or 1)
+                        }
+                    }
+                else:
+                    no_exists = {}
+
+        # 如果媒体已存在，执行订阅完成操作
+        if exist_flag:
+            if not subscribe.best_version:
+                logger.info(f'{mediainfo.title_year} 媒体库中已存在')
+            self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo, force=True)
+            return True, no_exists
+
+        # 获取已下载的集数或电影
+        downloaded = self.__get_downloaded(subscribe)
+        if meta.type == MediaType.TV:
+            # 对于电视剧类型，整合缺失集数并剔除已下载的集数
+            exist_flag, no_exists = self.__get_subscribe_no_exits(
+                subscribe_name=f'{subscribe.name} {meta.season}',
+                no_exists=no_exists,
+                mediakey=mediakey,
+                begin_season=meta.begin_season,
+                total_episode=subscribe.total_episode,
+                start_episode=subscribe.start_episode,
+                downloaded_episodes=downloaded
+            )
+        elif meta.type == MediaType.MOVIE:
+            # 对于电影类型，直接根据是否已下载判断
+            exist_flag = bool(downloaded)
+
+        # 如果已下载完毕，执行订阅完成操作
+        if exist_flag:
+            logger.info(f'{mediainfo.title_year} 已全部下载')
+            self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo, force=True)
+            return True, no_exists
+
+        # 返回结果，表示媒体未完全下载或存在
+        return False, no_exists
+
     @staticmethod
     def get_states_for_search(state: str) -> str:
         """
@@ -1332,3 +1363,24 @@ class SubscribeChain(ChainBase, metaclass=Singleton):
         if state in ["R", "P"]:
             return "R,P"
         return state
+
+    @staticmethod
+    def get_subscribe_source_keyword(subscribe: Subscribe) -> str:
+        """
+        构造用于订阅来源的关键字字符串
+        :param subscribe: Subscribe 对象
+        :return: 格式化的订阅来源关键字字符串，格式为 "Subscribe|{...}"
+        """
+        source_keyword = {
+            'id': subscribe.id,
+            'name': subscribe.name,
+            'year': subscribe.year,
+            'type': subscribe.type,
+            'season': subscribe.season,
+            'tmdbid': subscribe.tmdbid,
+            'imdbid': subscribe.imdbid,
+            'tvdbid': subscribe.tvdbid,
+            'doubanid': subscribe.doubanid,
+            'bangumiid': subscribe.bangumiid
+        }
+        return f"Subscribe|{json.dumps(source_keyword, ensure_ascii=False)}"

app/chain/transfer.py

@@ -330,7 +330,7 @@ class TransferChain(ChainBase):
             # 自定义识别
             if formaterHandler:
                 # 开始集、结束集、PART
-                begin_ep, end_ep, part = formaterHandler.split_episode(file_path.name)
+                begin_ep, end_ep, part = formaterHandler.split_episode(file_name=file_path.name, file_meta=file_meta)
                 if begin_ep is not None:
                     file_meta.begin_episode = begin_ep
                     file_meta.part = part

app/core/config.py

@@ -481,6 +481,7 @@ class Settings(BaseSettings, ConfigModel):
                 "refresh": 100,
                 "tmdb": 1024,
                 "douban": 512,
+                "bangumi": 512,
                 "fanart": 512,
                 "meta": (self.META_CACHE_EXPIRE or 24) * 3600
             }
@@ -489,6 +490,7 @@ class Settings(BaseSettings, ConfigModel):
             "refresh": 50,
             "tmdb": 256,
             "douban": 256,
+            "bangumi": 256,
             "fanart": 128,
             "meta": (self.META_CACHE_EXPIRE or 2) * 3600
         }

app/core/context.py

@@ -1,5 +1,6 @@
 import re
 from dataclasses import dataclass, field, asdict
+from datetime import datetime
 from typing import List, Dict, Any, Tuple
 
 from app.core.config import settings
@@ -123,6 +124,20 @@ class TorrentInfo:
             return ""
         return StringUtils.diff_time_str(self.freedate)
 
+    def pub_minutes(self) -> float:
+        """
+        返回发布时间距离当前时间的分钟数
+        """
+        if not self.pubdate:
+            return 0
+        try:
+            pub_date = datetime.strptime(self.pubdate, "%Y-%m-%d %H:%M:%S")
+            now_datetime = datetime.now()
+            return (now_datetime - pub_date).total_seconds() // 60
+        except Exception as e:
+            print(f"种子发布时间获取失败: {e}")
+            return 0
+
     def to_dict(self):
         """
         返回字典

app/core/event.py

@@ -502,13 +502,15 @@ class EventManager(metaclass=Singleton):
             }
         )
 
-    def register(self, etype: Union[EventType, ChainEventType, List[Union[EventType, ChainEventType]], type]):
+    def register(self, etype: Union[EventType, ChainEventType, List[Union[EventType, ChainEventType]], type],
+                 priority: int = DEFAULT_EVENT_PRIORITY):
         """
         事件注册装饰器，用于将函数注册为事件的处理器
         :param etype:
             - 单个事件类型成员 (如 EventType.MetadataScrape, ChainEventType.PluginAction)
             - 事件类型类 (EventType, ChainEventType)
             - 或事件类型成员的列表
+        :param priority: 可选，链式事件的优先级，默认为 DEFAULT_EVENT_PRIORITY
         """
 
         def decorator(f: Callable):
@@ -516,23 +518,18 @@ class EventManager(metaclass=Singleton):
             if isinstance(etype, list):
                 # 传入的已经是列表，直接使用
                 event_list = etype
-            elif etype is EventType:
-                # 订阅所有事件
-                event_list = []
-                for et in etype:
-                    event_list.append(et)
             else:
                 # 不是列表则包裹成单一元素的列表
                 event_list = [etype]
 
-                # 遍历列表，处理每个事件类型
+            # 遍历列表，处理每个事件类型
             for event in event_list:
                 if isinstance(event, (EventType, ChainEventType)):
-                    self.add_event_listener(event, f)
+                    self.add_event_listener(event, f, priority)
                 elif isinstance(event, type) and issubclass(event, (EventType, ChainEventType)):
                     # 如果是 EventType 或 ChainEventType 类，提取该类中的所有成员
                     for et in event.__members__.values():
-                        self.add_event_listener(et, f)
+                        self.add_event_listener(et, f, priority)
                 else:
                     raise ValueError(f"无效的事件类型: {event}")
 

app/db/models/siteuserdata.py

@@ -1,6 +1,6 @@
 from datetime import datetime
 
-from sqlalchemy import Column, Integer, String, Sequence, Float, JSON, func
+from sqlalchemy import Column, Integer, String, Sequence, Float, JSON, func, or_
 from sqlalchemy.orm import Session
 
 from app.db import db_query, Base
@@ -81,7 +81,7 @@ class SiteUserData(Base):
                 func.max(SiteUserData.updated_day).label('latest_update_day')
             )
             .group_by(SiteUserData.domain)
-            .filter(SiteUserData.err_msg is None)
+            .filter(or_(SiteUserData.err_msg.is_(None), SiteUserData.err_msg == ""))
             .subquery()
         )
 

app/db/site_oper.py

@@ -114,7 +114,8 @@ class SiteOper(DbOper):
             "domain": domain,
             "name": name,
             "updated_day": current_day,
-            "updated_time": current_time
+            "updated_time": current_time,
+            "err_msg": payload.get("err_msg") or ""
         })
         # 按站点+天判断是否存在数据
         siteuserdatas = SiteUserData.get_by_domain(self._db, domain=domain, workdate=current_day)

app/helper/format.py

@@ -3,6 +3,8 @@ from typing import Tuple, Optional
 
 import parse
 
+from app.core.meta.metabase import MetaBase
+
 
 class FormatParser(object):
     _key = ""
@@ -77,7 +79,7 @@ class FormatParser(object):
             return True
         return False
 
-    def split_episode(self, file_name: str) -> Tuple[Optional[int], Optional[int], Optional[str]]:
+    def split_episode(self, file_name: str, file_meta: MetaBase) -> Tuple[Optional[int], Optional[int], Optional[str]]:
         """
         拆分集数，返回开始集数，结束集数，Part信息
         """
@@ -94,7 +96,9 @@ class FormatParser(object):
                 start_ep = self.__offset.replace("EP", str(self._start_ep))
                 return int(eval(start_ep)), None, self.part
         if not self._format:
-            return self._start_ep, self._end_ep, self.part
+            start_ep = eval(self.__offset.replace("EP", str(file_meta.begin_episode))) if file_meta.begin_episode else None
+            end_ep = eval(self.__offset.replace("EP", str(file_meta.end_episode))) if file_meta.end_episode else None
+            return int(start_ep) if start_ep else None, int(end_ep) if end_ep else None, self.part
         else:
             s, e = self.__handle_single(file_name)
             start_ep = self.__offset.replace("EP", str(s)) if s else None

app/helper/torrent.py

@@ -64,10 +64,10 @@ class TorrentHelper(metaclass=Singleton):
             if not req.content:
                 return None, None, "", [], "未下载到种子数据"
             # 解析内容格式
-            if req.text and str(req.text).startswith("magnet:"):
+            if req.content.startswith(b"magnet:"):
                 # 磁力链接
                 return None, req.text, "", [], f"获取到磁力链接"
-            elif req.text and "下载种子文件" in req.text:
+            if "下载种子文件".encode("utf-8") in req.content:
                 # 首次下载提示页面
                 skip_flag = False
                 try:

app/modules/bangumi/bangumi.py

@@ -2,7 +2,9 @@ from datetime import datetime
 from functools import lru_cache
 
 import requests
+from cachetools import TTLCache, cached
 
+from app.core.config import settings
 from app.utils.http import RequestUtils
 
 
@@ -28,7 +30,7 @@ class BangumiApi(object):
         pass
 
     @classmethod
-    @lru_cache(maxsize=128)
+    @cached(cache=TTLCache(maxsize=settings.CACHE_CONF["bangumi"], ttl=settings.CACHE_CONF["meta"]))
     def __invoke(cls, url, **kwargs):
         req_url = cls._base_url + url
         params = {}

app/modules/douban/apiv2.py

@@ -175,6 +175,19 @@ class DoubanApi(metaclass=Singleton):
         ).decode()
 
     @cached(cache=TTLCache(maxsize=settings.CACHE_CONF["douban"], ttl=settings.CACHE_CONF["meta"]))
+    def __invoke_recommend(self, url: str, **kwargs) -> dict:
+        """
+        推荐/发现类API
+        """
+        return self.__invoke(url, **kwargs)
+
+    @cached(cache=TTLCache(maxsize=settings.CACHE_CONF["douban"], ttl=settings.CACHE_CONF["meta"]))
+    def __invoke_search(self, url: str, **kwargs) -> dict:
+        """
+        搜索类API
+        """
+        return self.__invoke(url, **kwargs)
+
     def __invoke(self, url: str, **kwargs) -> dict:
         """
         GET请求
@@ -244,189 +257,189 @@ class DoubanApi(metaclass=Singleton):
         """
         关键字搜索
         """
-        return self.__invoke(self._urls["search"], q=keyword,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["search"], q=keyword,
+                                    start=start, count=count, _ts=ts)
 
     def movie_search(self, keyword: str, start: int = 0, count: int = 20,
                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         电影搜索
         """
-        return self.__invoke(self._urls["movie_search"], q=keyword,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["movie_search"], q=keyword,
+                                    start=start, count=count, _ts=ts)
 
     def tv_search(self, keyword: str, start: int = 0, count: int = 20,
                   ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         电视搜索
         """
-        return self.__invoke(self._urls["tv_search"], q=keyword,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["tv_search"], q=keyword,
+                                    start=start, count=count, _ts=ts)
 
     def book_search(self, keyword: str, start: int = 0, count: int = 20,
                     ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         书籍搜索
         """
-        return self.__invoke(self._urls["book_search"], q=keyword,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["book_search"], q=keyword,
+                                    start=start, count=count, _ts=ts)
 
     def group_search(self, keyword: str, start: int = 0, count: int = 20,
                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         小组搜索
         """
-        return self.__invoke(self._urls["group_search"], q=keyword,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["group_search"], q=keyword,
+                                    start=start, count=count, _ts=ts)
 
     def person_search(self, keyword: str, start: int = 0, count: int = 20,
                       ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         人物搜索
         """
-        return self.__invoke(self._urls["search_subject"], type="person", q=keyword,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["search_subject"], type="person", q=keyword,
+                                    start=start, count=count, _ts=ts)
 
     def movie_showing(self, start: int = 0, count: int = 20,
                       ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         正在热映
         """
-        return self.__invoke(self._urls["movie_showing"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["movie_showing"],
+                                       start=start, count=count, _ts=ts)
 
     def movie_soon(self, start: int = 0, count: int = 20,
                    ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         即将上映
         """
-        return self.__invoke(self._urls["movie_soon"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["movie_soon"],
+                                       start=start, count=count, _ts=ts)
 
     def movie_hot_gaia(self, start: int = 0, count: int = 20,
                        ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         热门电影
         """
-        return self.__invoke(self._urls["movie_hot_gaia"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["movie_hot_gaia"],
+                                       start=start, count=count, _ts=ts)
 
     def tv_hot(self, start: int = 0, count: int = 20,
                ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         热门剧集
         """
-        return self.__invoke(self._urls["tv_hot"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_hot"],
+                                       start=start, count=count, _ts=ts)
 
     def tv_animation(self, start: int = 0, count: int = 20,
                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         动画
         """
-        return self.__invoke(self._urls["tv_animation"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_animation"],
+                                       start=start, count=count, _ts=ts)
 
     def tv_variety_show(self, start: int = 0, count: int = 20,
                         ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         综艺
         """
-        return self.__invoke(self._urls["tv_variety_show"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_variety_show"],
+                                       start=start, count=count, _ts=ts)
 
     def tv_rank_list(self, start: int = 0, count: int = 20,
                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         电视剧排行榜
         """
-        return self.__invoke(self._urls["tv_rank_list"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_rank_list"],
+                                       start=start, count=count, _ts=ts)
 
     def show_hot(self, start: int = 0, count: int = 20,
                  ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         综艺热门
         """
-        return self.__invoke(self._urls["show_hot"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["show_hot"],
+                                       start=start, count=count, _ts=ts)
 
     def movie_detail(self, subject_id: str):
         """
         电影详情
         """
-        return self.__invoke(self._urls["movie_detail"] + subject_id)
+        return self.__invoke_search(self._urls["movie_detail"] + subject_id)
 
     def movie_celebrities(self, subject_id: str):
         """
         电影演职员
         """
-        return self.__invoke(self._urls["movie_celebrities"] % subject_id)
+        return self.__invoke_search(self._urls["movie_celebrities"] % subject_id)
 
     def tv_detail(self, subject_id: str):
         """
         电视剧详情
         """
-        return self.__invoke(self._urls["tv_detail"] + subject_id)
+        return self.__invoke_search(self._urls["tv_detail"] + subject_id)
 
     def tv_celebrities(self, subject_id: str):
         """
         电视剧演职员
         """
-        return self.__invoke(self._urls["tv_celebrities"] % subject_id)
+        return self.__invoke_search(self._urls["tv_celebrities"] % subject_id)
 
     def book_detail(self, subject_id: str):
         """
         书籍详情
         """
-        return self.__invoke(self._urls["book_detail"] + subject_id)
+        return self.__invoke_search(self._urls["book_detail"] + subject_id)
 
     def movie_top250(self, start: int = 0, count: int = 20,
                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         电影TOP250
         """
-        return self.__invoke(self._urls["movie_top250"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["movie_top250"],
+                                       start=start, count=count, _ts=ts)
 
     def movie_recommend(self, tags='', sort='R', start: int = 0, count: int = 20,
                         ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         电影探索
         """
-        return self.__invoke(self._urls["movie_recommend"], tags=tags, sort=sort,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["movie_recommend"], tags=tags, sort=sort,
+                                       start=start, count=count, _ts=ts)
 
     def tv_recommend(self, tags='', sort='R', start: int = 0, count: int = 20,
                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         电视剧探索
         """
-        return self.__invoke(self._urls["tv_recommend"], tags=tags, sort=sort,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_recommend"], tags=tags, sort=sort,
+                                       start=start, count=count, _ts=ts)
 
     def tv_chinese_best_weekly(self, start: int = 0, count: int = 20,
                                ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         华语口碑周榜
         """
-        return self.__invoke(self._urls["tv_chinese_best_weekly"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_chinese_best_weekly"],
+                                       start=start, count=count, _ts=ts)
 
     def tv_global_best_weekly(self, start: int = 0, count: int = 20,
                               ts=datetime.strftime(datetime.now(), '%Y%m%d')):
         """
         全球口碑周榜
         """
-        return self.__invoke(self._urls["tv_global_best_weekly"],
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_global_best_weekly"],
+                                       start=start, count=count, _ts=ts)
 
     def doulist_detail(self, subject_id: str):
         """
         豆列详情
         :param subject_id: 豆列id
         """
-        return self.__invoke(self._urls["doulist"] + subject_id)
+        return self.__invoke_search(self._urls["doulist"] + subject_id)
 
     def doulist_items(self, subject_id: str, start: int = 0, count: int = 20,
                       ts=datetime.strftime(datetime.now(), '%Y%m%d')):
@@ -437,8 +450,8 @@ class DoubanApi(metaclass=Singleton):
         :param count: 数量
         :param ts: 时间戳
         """
-        return self.__invoke(self._urls["doulist_items"] % subject_id,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["doulist_items"] % subject_id,
+                                    start=start, count=count, _ts=ts)
 
     def movie_recommendations(self, subject_id: str, start: int = 0, count: int = 20,
                               ts=datetime.strftime(datetime.now(), '%Y%m%d')):
@@ -449,8 +462,8 @@ class DoubanApi(metaclass=Singleton):
         :param count: 数量
         :param ts: 时间戳
         """
-        return self.__invoke(self._urls["movie_recommendations"] % subject_id,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["movie_recommendations"] % subject_id,
+                                       start=start, count=count, _ts=ts)
 
     def tv_recommendations(self, subject_id: str, start: int = 0, count: int = 20,
                            ts=datetime.strftime(datetime.now(), '%Y%m%d')):
@@ -461,8 +474,8 @@ class DoubanApi(metaclass=Singleton):
         :param count: 数量
         :param ts: 时间戳
         """
-        return self.__invoke(self._urls["tv_recommendations"] % subject_id,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_recommend(self._urls["tv_recommendations"] % subject_id,
+                                       start=start, count=count, _ts=ts)
 
     def movie_photos(self, subject_id: str, start: int = 0, count: int = 20,
                      ts=datetime.strftime(datetime.now(), '%Y%m%d')):
@@ -473,8 +486,8 @@ class DoubanApi(metaclass=Singleton):
         :param count: 数量
         :param ts: 时间戳
         """
-        return self.__invoke(self._urls["movie_photos"] % subject_id,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["movie_photos"] % subject_id,
+                                    start=start, count=count, _ts=ts)
 
     def tv_photos(self, subject_id: str, start: int = 0, count: int = 20,
                   ts=datetime.strftime(datetime.now(), '%Y%m%d')):
@@ -485,8 +498,8 @@ class DoubanApi(metaclass=Singleton):
         :param count: 数量
         :param ts: 时间戳
         """
-        return self.__invoke(self._urls["tv_photos"] % subject_id,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["tv_photos"] % subject_id,
+                                    start=start, count=count, _ts=ts)
 
     def person_detail(self, subject_id: int):
         """
@@ -494,7 +507,7 @@ class DoubanApi(metaclass=Singleton):
         :param subject_id: 人物 id
         :return:
         """
-        return self.__invoke(self._urls["person_detail"] + str(subject_id))
+        return self.__invoke_search(self._urls["person_detail"] + str(subject_id))
 
     def person_work(self, subject_id: int, start: int = 0, count: int = 20, sort_by: str = "time",
                     collection_title: str = "影视",
@@ -509,14 +522,16 @@ class DoubanApi(metaclass=Singleton):
         :param ts: 时间戳
         :return:
         """
-        return self.__invoke(self._urls["person_work"] % subject_id, sortby=sort_by, collection_title=collection_title,
-                             start=start, count=count, _ts=ts)
+        return self.__invoke_search(self._urls["person_work"] % subject_id, sortby=sort_by,
+                                    collection_title=collection_title,
+                                    start=start, count=count, _ts=ts)
 
     def clear_cache(self):
         """
         清空LRU缓存
         """
-        self.__invoke.cache_clear()
+        # 尚未支持缓存清理
+        pass
 
     def close(self):
         if self._session:

app/modules/filemanager/storages/alist.py

@@ -553,15 +553,15 @@ class Alist(StorageBase, metaclass=Singleton):
         :param new_name: 上传后文件名
         :param task: 是否为任务，默认为False避免未完成上传时对文件进行操作
         """
-        encoded_path = UrlUtils.quote(fileitem.path)
+        encoded_path = UrlUtils.quote(fileitem.path + path.name)
         headers = self.__get_header_with_token()
-        headers.setdefault("Content-Type", "multipart/form-data")
+        headers.setdefault("Content-Type", "application/octet-stream")
         headers.setdefault("As-Task", str(task).lower())
         headers.setdefault("File-Path", encoded_path)
         with open(path, "rb") as f:
             resp: Response = RequestUtils(headers=headers).put_res(
-                self.__get_api_url("/api/fs/form"),
-                data={"file": f},
+                self.__get_api_url("/api/fs/put"),
+                data=f,
             )
 
         if resp.status_code != 200:

app/modules/filemanager/storages/rclone.py

@@ -1,4 +1,3 @@
-import copy
 import json
 import subprocess
 from pathlib import Path
@@ -57,21 +56,6 @@ class Rclone(StorageBase):
         else:
             return None
 
-    def __get_fileitem(self, path: Path):
-        """
-        获取文件项
-        """
-        return schemas.FileItem(
-            storage=self.schema.value,
-            type="file",
-            path=str(path).replace("\\", "/"),
-            name=path.name,
-            basename=path.stem,
-            extension=path.suffix[1:],
-            size=path.stat().st_size,
-            modify_time=path.stat().st_mtime,
-        )
-
     def __get_rcloneitem(self, item: dict, parent: str = "/") -> schemas.FileItem:
         """
         获取rclone文件项
@@ -146,12 +130,12 @@ class Rclone(StorageBase):
             retcode = subprocess.run(
                 [
                     'rclone', 'mkdir',
-                    f'MP:{fileitem.path}/{name}'
+                    f'MP:{Path(fileitem.path) / name}'
                 ],
                 startupinfo=self.__get_hidden_shell()
             ).returncode
             if retcode == 0:
-                return self.get_item(Path(f"{fileitem.path}/{name}"))
+                return self.get_item(Path(fileitem.path) / name)
         except Exception as err:
             logger.error(f"rclone创建目录失败：{err}")
         return None
@@ -200,16 +184,19 @@ class Rclone(StorageBase):
             ret = subprocess.run(
                 [
                     'rclone', 'lsjson',
-                    f'MP:{path}'
+                    f'MP:{path.parent}'
                 ],
                 capture_output=True,
                 startupinfo=self.__get_hidden_shell()
             )
             if ret.returncode == 0:
                 items = json.loads(ret.stdout)
-                return self.__get_rcloneitem(items[0])
+                for item in items:
+                    if item.get("Name") == path.name:
+                        return self.__get_rcloneitem(item, parent=str(path.parent) + "/")
+            return None
         except Exception as err:
-            logger.error(f"rclone获取文件失败：{err}")
+            logger.debug(f"rclone获取文件项失败：{err}")
         return None
 
     def delete(self, fileitem: schemas.FileItem) -> bool:
@@ -239,7 +226,7 @@ class Rclone(StorageBase):
                 [
                     'rclone', 'moveto',
                     f'MP:{fileitem.path}',
-                    f'MP:{Path(fileitem.path).parent}/{name}'
+                    f'MP:{Path(fileitem.path).parent / name}'
                 ],
                 startupinfo=self.__get_hidden_shell()
             ).returncode
@@ -287,7 +274,7 @@ class Rclone(StorageBase):
                 startupinfo=self.__get_hidden_shell()
             ).returncode
             if retcode == 0:
-                return self.__get_fileitem(new_path)
+                return self.get_item(new_path)
         except Exception as err:
             logger.error(f"rclone上传文件失败：{err}")
         return None

app/modules/filter/__init__.py

@@ -366,6 +366,8 @@ class FilterModule(_ModuleBase):
         seeders = self.rule_set[rule_name].get("seeders")
         # FREE规则
         downloadvolumefactor = self.rule_set[rule_name].get("downloadvolumefactor")
+        # 发布时间规则
+        pubdate: str = self.rule_set[rule_name].get("publish_time")
         if includes and not any(re.search(r"%s" % include, content, re.IGNORECASE) for include in includes):
             # 未发现任何包含项
             logger.debug(f"种子 {torrent.site_name} - {torrent.title} 不包含任何项 {includes}")
@@ -392,6 +394,22 @@ class FilterModule(_ModuleBase):
                 logger.debug(
                     f"种子 {torrent.site_name} - {torrent.title} FREE值 {torrent.downloadvolumefactor} 不是 {downloadvolumefactor}")
                 return False
+        if pubdate:
+            # 种子发布时间
+            pub_minutes = torrent.pub_minutes()
+            # 发布时间规则
+            pub_times = [float(t) for t in pubdate.split("-")]
+            if len(pub_times) == 1:
+                # 发布时间小于规则
+                if pub_minutes < pub_times[0]:
+                    logger.debug(f"种子 {torrent.site_name} - {torrent.title} 发布时间 {pub_minutes} 小于 {pub_times[0]}")
+                    return False
+            else:
+                # 区间
+                if not (pub_times[0] <= pub_minutes <= pub_times[1]):
+                    logger.debug(f"种子 {torrent.site_name} - {torrent.title} 发布时间 {pub_minutes} 不在 {pub_times[0]}-{pub_times[1]} 时间区间")
+                    return False
+
         return True
 
     def __match_tmdb(self, tmdb: dict) -> bool:

app/plugins/__init__.py

@@ -225,7 +225,7 @@ class _PluginBase(metaclass=ABCMeta):
         return self.plugindata.del_data(plugin_id, key)
 
     def post_message(self, channel: MessageChannel = None, mtype: NotificationType = None, title: str = None,
-                     text: str = None, image: str = None, link: str = None, userid: str = None):
+                     text: str = None, image: str = None, link: str = None, userid: str = None, username: str = None):
         """
         发送消息
         """
@@ -233,7 +233,7 @@ class _PluginBase(metaclass=ABCMeta):
             link = settings.MP_DOMAIN(f"#/plugins?tab=installed&id={self.__class__.__name__}")
         self.chain.post_message(Notification(
             channel=channel, mtype=mtype, title=title, text=text,
-            image=image, link=link, userid=userid
+            image=image, link=link, userid=userid, username=username
         ))
 
     def close(self):

app/schemas/event.py

@@ -165,6 +165,7 @@ class ResourceSelectionEventData(BaseModel):
     # 输入参数
     contexts: Any = Field(None, description="待选择的资源上下文列表")
     downloader: Optional[str] = Field(None, description="下载器")
+    origin: Optional[str] = Field(None, description="来源")
 
     # 输出参数
     updated: bool = Field(False, description="是否已更新")

app/schemas/transfer.py

@@ -89,3 +89,42 @@ class EpisodeFormat(BaseModel):
     detail: Optional[str] = None
     part: Optional[str] = None
     offset: Optional[str] = None
+
+
+class ManualTransferItem(BaseModel):
+    # 文件项
+    fileitem: FileItem = None
+    # 日志ID
+    logid: Optional[int] = None
+    # 目标存储
+    target_storage: Optional[str] = None
+    # 目标路径
+    target_path: Optional[str] = None
+    # TMDB ID
+    tmdbid: Optional[int] = None
+    # 豆瓣ID
+    doubanid: Optional[str] = None
+    # 类型
+    type_name: Optional[str] = None
+    # 季号
+    season: Optional[int] = None
+    # 整理方式
+    transfer_type: Optional[str] = None
+    # 自定义格式
+    episode_format: Optional[str] = None
+    # 指定集数
+    episode_detail: Optional[str] = None
+    # 指定PART
+    episode_part: Optional[str] = None
+    # 集数偏移
+    episode_offset: Optional[str] = None
+    # 最小文件大小
+    min_filesize: Optional[int] = 0
+    # 刮削
+    scrape: bool = False
+    # 媒体库类型子目录
+    library_type_folder: Optional[bool] = None
+    # 媒体库类别子目录
+    library_category_folder: Optional[bool] = None
+    # 复用历史识别信息
+    from_history: Optional[bool] = False

app/schemas/types.py

@@ -48,6 +48,8 @@ class EventType(Enum):
     NoticeMessage = "notice.message"
     # 订阅已添加
     SubscribeAdded = "subscribe.added"
+    # 订阅已删除
+    SubscribeDeleted = "subscribe.deleted"
     # 订阅已完成
     SubscribeComplete = "subscribe.complete"
     # 系统错误

requirements.in

@@ -58,6 +58,8 @@ pystray~=0.19.5
 pyotp~=2.9.0
 Pinyin2Hanzi~=0.1.1
 pywebpush~=2.0.0
-python-115~=0.0.9.8.8.2
+python-115==0.0.9.8.8.2
+p115client==0.0.3.8.3.3
+python-cookietools==0.0.2.1
 aligo~=6.2.4
 aiofiles~=24.1.0

version.py

@@ -1,2 +1,2 @@
-APP_VERSION = 'v2.1.2'
-FRONTEND_VERSION = 'v2.1.2'
+APP_VERSION = 'v2.1.4'
+FRONTEND_VERSION = 'v2.1.4'