import json import random import time from datetime import datetime from json import JSONDecodeError from typing import Dict, List, Optional, Union, Tuple from app.chain import ChainBase from app.chain.download import DownloadChain from app.chain.media import MediaChain from app.chain.search import SearchChain from app.chain.torrents import TorrentsChain from app.core.config import settings from app.core.context import TorrentInfo, Context, MediaInfo from app.core.event import eventmanager, Event, EventManager from app.core.meta import MetaBase from app.core.metainfo import MetaInfo from app.db.models.subscribe import Subscribe from app.db.site_oper import SiteOper from app.db.subscribe_oper import SubscribeOper from app.db.subscribehistory_oper import SubscribeHistoryOper from app.db.systemconfig_oper import SystemConfigOper from app.helper.message import MessageHelper from app.helper.subscribe import SubscribeHelper from app.helper.torrent import TorrentHelper from app.log import logger from app.schemas import NotExistMediaInfo, Notification from app.schemas.types import MediaType, SystemConfigKey, MessageChannel, NotificationType, EventType class SubscribeChain(ChainBase): """ 订阅管理处理链 """ def __init__(self): super().__init__() self.downloadchain = DownloadChain() self.searchchain = SearchChain() self.subscribeoper = SubscribeOper() self.subscribehistoryoper = SubscribeHistoryOper() self.subscribehelper = SubscribeHelper() self.torrentschain = TorrentsChain() self.mediachain = MediaChain() self.message = MessageHelper() self.systemconfig = SystemConfigOper() self.torrenthelper = TorrentHelper() self.siteoper = SiteOper() def add(self, title: str, year: str, mtype: MediaType = None, tmdbid: int = None, doubanid: str = None, bangumiid: int = None, season: int = None, channel: MessageChannel = None, userid: str = None, username: str = None, message: bool = True, exist_ok: bool = False, **kwargs) -> Tuple[Optional[int], str]: """ 识别媒体信息并添加订阅 """ logger.info(f'开始添加订阅，标题：{title} ...') mediainfo = None metainfo = MetaInfo(title) if year: metainfo.year = year if mtype: metainfo.type = mtype if season: metainfo.type = MediaType.TV metainfo.begin_season = season # 识别媒体信息 if settings.RECOGNIZE_SOURCE == "themoviedb": # TMDB识别模式 if not tmdbid and doubanid: # 将豆瓣信息转换为TMDB信息 tmdbinfo = self.mediachain.get_tmdbinfo_by_doubanid(doubanid=doubanid, mtype=mtype) if tmdbinfo: mediainfo = MediaInfo(tmdb_info=tmdbinfo) else: # 识别TMDB信息，不使用缓存 mediainfo = self.recognize_media(meta=metainfo, mtype=mtype, tmdbid=tmdbid, cache=False) else: # 豆瓣识别模式，不使用缓存 mediainfo = self.recognize_media(meta=metainfo, mtype=mtype, doubanid=doubanid, cache=False) if mediainfo: # 豆瓣标题处理 meta = MetaInfo(mediainfo.title) mediainfo.title = meta.name if not season: season = meta.begin_season # 识别失败 if not mediainfo: logger.warn(f'未识别到媒体信息，标题：{title}，tmdbid：{tmdbid}，doubanid：{doubanid}') return None, "未识别到媒体信息" # 总集数 if mediainfo.type == MediaType.TV: if not season: season = 1 # 总集数 if not kwargs.get('total_episode'): if not mediainfo.seasons: # 补充媒体信息 mediainfo = self.recognize_media(mtype=mediainfo.type, tmdbid=mediainfo.tmdb_id, doubanid=mediainfo.douban_id, bangumiid=mediainfo.bangumi_id, cache=False) if not mediainfo: logger.error(f"媒体信息识别失败！") return None, "媒体信息识别失败" if not mediainfo.seasons: logger.error(f"媒体信息中没有季集信息，标题：{title}，tmdbid：{tmdbid}，doubanid：{doubanid}") return None, "媒体信息中没有季集信息" total_episode = len(mediainfo.seasons.get(season) or []) if not total_episode: logger.error(f'未获取到总集数，标题：{title}，tmdbid：{tmdbid}, doubanid：{doubanid}') return None, f"未获取到第 {season} 季的总集数" kwargs.update({ 'total_episode': total_episode }) # 缺失集 if not kwargs.get('lack_episode'): kwargs.update({ 'lack_episode': kwargs.get('total_episode') }) else: # 避免season为0的问题 season = None # 更新媒体图片 self.obtain_images(mediainfo=mediainfo) # 合并信息 if doubanid: mediainfo.douban_id = doubanid if bangumiid: mediainfo.bangumi_id = bangumiid # 添加订阅 kwargs.update({ 'quality': self.__get_default_subscribe_config(mediainfo.type, "quality") if not kwargs.get( "quality") else kwargs.get("quality"), 'resolution': self.__get_default_subscribe_config(mediainfo.type, "resolution") if not kwargs.get( "resolution") else kwargs.get("resolution"), 'effect': self.__get_default_subscribe_config(mediainfo.type, "effect") if not kwargs.get( "effect") else kwargs.get("effect"), 'include': self.__get_default_subscribe_config(mediainfo.type, "include") if not kwargs.get( "include") else kwargs.get("include"), 'exclude': self.__get_default_subscribe_config(mediainfo.type, "exclude") if not kwargs.get( "exclude") else kwargs.get("exclude"), 'best_version': self.__get_default_subscribe_config(mediainfo.type, "best_version") if not kwargs.get( "best_version") else kwargs.get("best_version"), 'search_imdbid': self.__get_default_subscribe_config(mediainfo.type, "search_imdbid") if not kwargs.get( "search_imdbid") else kwargs.get("search_imdbid"), 'sites': self.__get_default_subscribe_config(mediainfo.type, "sites") or None if not kwargs.get( "sites") else kwargs.get("sites"), 'save_path': self.__get_default_subscribe_config(mediainfo.type, "save_path") if not kwargs.get( "save_path") else kwargs.get("save_path") }) sid, err_msg = self.subscribeoper.add(mediainfo=mediainfo, season=season, username=username, **kwargs) if not sid: logger.error(f'{mediainfo.title_year} {err_msg}') if not exist_ok and message: # 发回原用户 self.post_message(Notification(channel=channel, mtype=NotificationType.Subscribe, title=f"{mediainfo.title_year} {metainfo.season} " f"添加订阅失败！", text=f"{err_msg}", image=mediainfo.get_message_image(), userid=userid)) return None, err_msg elif message: logger.info(f'{mediainfo.title_year} {metainfo.season} 添加订阅成功') if username: text = f"评分：{mediainfo.vote_average}，来自用户：{username}" else: text = f"评分：{mediainfo.vote_average}" # 群发 if mediainfo.type == MediaType.TV: link = settings.MP_DOMAIN('#/subscribe/tv?tab=mysub') else: link = settings.MP_DOMAIN('#/subscribe/movie?tab=mysub') self.post_message(Notification(mtype=NotificationType.Subscribe, title=f"{mediainfo.title_year} {metainfo.season} 已添加订阅", text=text, image=mediainfo.get_message_image(), link=link)) # 发送事件 EventManager().send_event(EventType.SubscribeAdded, { "subscribe_id": sid, "username": username, "mediainfo": mediainfo.to_dict(), }) # 统计订阅 self.subscribehelper.sub_reg_async({ "name": title, "year": year, "type": metainfo.type.value, "tmdbid": mediainfo.tmdb_id, "imdbid": mediainfo.imdb_id, "tvdbid": mediainfo.tvdb_id, "doubanid": mediainfo.douban_id, "bangumiid": mediainfo.bangumi_id, "season": metainfo.begin_season, "poster": mediainfo.get_poster_image(), "backdrop": mediainfo.get_backdrop_image(), "vote": mediainfo.vote_average, "description": mediainfo.overview }) # 返回结果 return sid, "" def exists(self, mediainfo: MediaInfo, meta: MetaBase = None): """ 判断订阅是否已存在 """ if self.subscribeoper.exists(tmdbid=mediainfo.tmdb_id, doubanid=mediainfo.douban_id, season=meta.begin_season if meta else None): return True return False def search(self, sid: int = None, state: str = 'N', manual: bool = False): """ 订阅搜索 :param sid: 订阅ID，有值时只处理该订阅 :param state: 订阅状态 N:未搜索 R:已搜索 :param manual: 是否手动搜索 :return: 更新订阅状态为R或删除订阅 """ if sid: subscribes = [self.subscribeoper.get(sid)] else: subscribes = self.subscribeoper.list(state) # 遍历订阅 for subscribe in subscribes: mediakey = subscribe.tmdbid or subscribe.doubanid # 校验当前时间减订阅创建时间是否大于1分钟，否则跳过先，留出编辑订阅的时间 if subscribe.date: now = datetime.now() subscribe_time = datetime.strptime(subscribe.date, '%Y-%m-%d %H:%M:%S') if (now - subscribe_time).total_seconds() < 60: logger.debug(f"订阅标题：{subscribe.name} 新增小于1分钟，暂不搜索...") continue # 随机休眠1-5分钟 if not sid and state == 'R': sleep_time = random.randint(60, 300) logger.info(f'订阅搜索随机休眠 {sleep_time} 秒 ...') time.sleep(sleep_time) logger.info(f'开始搜索订阅，标题：{subscribe.name} ...') # 如果状态为N则更新为R if subscribe.state == 'N': self.subscribeoper.update(subscribe.id, {'state': 'R'}) # 生成元数据 meta = MetaInfo(subscribe.name) meta.year = subscribe.year meta.begin_season = subscribe.season or None try: meta.type = MediaType(subscribe.type) except ValueError: logger.error(f'订阅 {subscribe.name} 类型错误：{subscribe.type}') continue # 识别媒体信息 mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type, tmdbid=subscribe.tmdbid, doubanid=subscribe.doubanid, cache=False) if not mediainfo: 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 = {} # 已存在 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) # 优先级过滤规则 if subscribe.best_version: priority_rule = self.systemconfig.get(SystemConfigKey.BestVersionFilterRules) else: priority_rule = self.systemconfig.get(SystemConfigKey.SubscribeFilterRules) # 过滤规则 filter_rule = self.get_filter_rule(subscribe) # 搜索，同时电视剧会过滤掉不需要的剧集 contexts = self.searchchain.process(mediainfo=mediainfo, keyword=subscribe.keyword, no_exists=no_exists, sites=sites, priority_rule=priority_rule, filter_rule=filter_rule, area="imdbid" if subscribe.search_imdbid else "title") if not contexts: logger.warn(f'订阅 {subscribe.keyword or subscribe.name} 未搜索到资源') self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo, lefts=no_exists) continue # 过滤搜索结果 matched_contexts = [] for context in contexts: torrent_meta = context.meta_info torrent_info = context.torrent_info torrent_mediainfo = context.media_info # 洗版 if subscribe.best_version: # 洗版时，非整季不要 if torrent_mediainfo.type == MediaType.TV: 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} 没有符合过滤条件的资源') self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo, lefts=no_exists) continue # 自动下载 downloads, lefts = self.downloadchain.batch_download( contexts=matched_contexts, no_exists=no_exists, userid=subscribe.username, username=subscribe.username, save_path=subscribe.save_path ) # 判断是否应完成订阅 self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo, downloads=downloads, lefts=lefts) # 手动触发时发送系统消息 if manual: if sid: self.message.put(f'{subscribes[0].name} 搜索完成！', title="订阅搜索", role="system") else: self.message.put('所有订阅搜索完成！', title="订阅搜索", role="system") def update_subscribe_priority(self, subscribe: Subscribe, meta: MetaInfo, mediainfo: MediaInfo, downloads: List[Context]): """ 更新订阅已下载资源的优先级 """ if not downloads: return if not subscribe.best_version: return # 当前下载资源的优先级 priority = max([item.torrent_info.pri_order for item in downloads]) if priority == 100: # 洗版完成 self.__finish_subscribe(subscribe=subscribe, meta=meta, mediainfo=mediainfo, bestversion=True) else: # 正在洗版，更新资源优先级 logger.info(f'{mediainfo.title_year} 正在洗版，更新资源优先级为 {priority}') self.subscribeoper.update(subscribe.id, { "current_priority": priority }) def finish_subscribe_or_not(self, subscribe: Subscribe, meta: MetaInfo, mediainfo: MediaInfo, downloads: List[Context] = None, lefts: Dict[Union[int | str], Dict[int, NotExistMediaInfo]] = None, force: bool = False): """ 判断是否应完成订阅 """ mediakey = subscribe.tmdbid or subscribe.doubanid # 是否有剩余集 no_lefts = not lefts or not lefts.get(mediakey) # 是否完成订阅 if not subscribe.best_version: # 非洗板 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) else: # 洗版，未下载到内容 logger.info(f'{mediainfo.title_year} 继续洗版 ...') def refresh(self): """ 订阅刷新 """ # 触发刷新站点资源，从缓存中匹配订阅 sites = self.get_subscribed_sites() if sites is None: return self.match( self.torrentschain.refresh(sites=sites) ) def get_sub_sites(self, subscribe: Subscribe) -> List[int]: """ 获取订阅中涉及的站点清单 :param subscribe: 订阅信息对象 :return: 涉及的站点清单 """ # 从系统配置获取默认订阅站点 default_sites = self.systemconfig.get(SystemConfigKey.RssSites) or [] # 如果订阅未指定站点信息，直接返回默认站点 if not subscribe.sites: return default_sites try: # 尝试解析订阅中的站点数据 user_sites = json.loads(subscribe.sites) # 计算 user_sites 和 default_sites 的交集 intersection_sites = [site for site in user_sites if site in default_sites] # 如果交集与原始订阅不一致，更新数据库 if set(intersection_sites) != set(user_sites): self.subscribeoper.update(subscribe.id, { "sites": json.dumps(intersection_sites) }) # 如果交集为空，返回默认站点 return intersection_sites if intersection_sites else default_sites except JSONDecodeError: # 如果 JSON 解析失败，返回默认站点 return default_sites def get_subscribed_sites(self) -> Optional[List[int]]: """ 获取订阅中涉及的所有站点清单（节约资源） :return: 返回[]代表所有站点命中，返回None代表没有订阅 """ # 查询所有订阅 subscribes = self.subscribeoper.list('R') if not subscribes: return None ret_sites = [] # 刷新订阅选中的Rss站点 for subscribe in subscribes: # 刷新选中的站点 ret_sites.extend(self.get_sub_sites(subscribe)) # 去重 if ret_sites: ret_sites = list(set(ret_sites)) return ret_sites def get_filter_rule(self, subscribe: Subscribe): """ 获取订阅过滤规则，同时组合默认规则 """ # 默认过滤规则 default_rule = self.systemconfig.get(SystemConfigKey.DefaultFilterRules) or {} return { "include": subscribe.include or default_rule.get("include"), "exclude": subscribe.exclude or default_rule.get("exclude"), "quality": subscribe.quality or default_rule.get("quality"), "resolution": subscribe.resolution or default_rule.get("resolution"), "effect": subscribe.effect or default_rule.get("effect"), "tv_size": default_rule.get("tv_size"), "movie_size": default_rule.get("movie_size"), "min_seeders": default_rule.get("min_seeders"), "min_seeders_time": default_rule.get("min_seeders_time"), } def match(self, torrents: Dict[str, List[Context]]): """ 从缓存中匹配订阅，并自动下载 """ if not torrents: logger.warn('没有缓存资源，无法匹配订阅') return # 记录重新识别过的种子 _recognize_cached = [] # 所有订阅 subscribes = self.subscribeoper.list('R') # 遍历订阅 for subscribe in subscribes: logger.info(f'开始匹配订阅，标题：{subscribe.name} ...') mediakey = subscribe.tmdbid or subscribe.doubanid # 生成元数据 meta = MetaInfo(subscribe.name) meta.year = subscribe.year meta.begin_season = subscribe.season or None try: meta.type = MediaType(subscribe.type) except ValueError: logger.error(f'订阅 {subscribe.name} 类型错误：{subscribe.type}') continue # 订阅的站点域名列表 domains = [] if subscribe.sites: try: siteids = json.loads(subscribe.sites) if siteids: domains = self.siteoper.get_domains_by_ids(siteids) except JSONDecodeError: pass # 识别媒体信息 mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type, tmdbid=subscribe.tmdbid, doubanid=subscribe.doubanid, cache=False) if not mediainfo: 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 = {} # 已存在 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) ) # 过滤规则 filter_rule = self.get_filter_rule(subscribe) # 遍历缓存种子 _match_context = [] for domain, contexts in torrents.items(): if domains and domain not in domains: continue logger.debug(f'开始匹配站点：{domain}，共缓存了 {len(contexts)} 个种子...') for context in contexts: # 检查是否匹配 torrent_meta = context.meta_info torrent_mediainfo = context.media_info torrent_info = context.torrent_info # 先判断是否有没识别的种子 if not torrent_mediainfo or (not torrent_mediainfo.tmdb_id and not torrent_mediainfo.douban_id): _cache_key = f"{torrent_info.title}_{torrent_info.description}" if _cache_key not in _recognize_cached: _recognize_cached.append(_cache_key) logger.info( f'{torrent_info.site_name} - {torrent_info.title} 订阅缓存为未识别状态，尝试重新识别...') # 重新识别（不使用缓存） torrent_mediainfo = self.recognize_media(meta=torrent_meta, cache=False) if not torrent_mediainfo: logger.warn( f'{torrent_info.site_name} - {torrent_info.title} 重新识别失败，尝试通过标题匹配...') if self.torrenthelper.match_torrent(mediainfo=mediainfo, torrent_meta=torrent_meta, torrent=torrent_info): # 匹配成功 logger.info( f'{mediainfo.title_year} 通过标题匹配到资源：{torrent_info.site_name} - {torrent_info.title}') # 更新缓存 torrent_mediainfo = mediainfo context.media_info = mediainfo else: continue # 直接比对媒体信息 if torrent_mediainfo and (torrent_mediainfo.tmdb_id or torrent_mediainfo.douban_id): if torrent_mediainfo.type != mediainfo.type: continue if torrent_mediainfo.tmdb_id \ and torrent_mediainfo.tmdb_id != mediainfo.tmdb_id: continue if torrent_mediainfo.douban_id \ and torrent_mediainfo.douban_id != mediainfo.douban_id: continue logger.info( f'{mediainfo.title_year} 通过媒体信ID匹配到资源：{torrent_info.site_name} - {torrent_info.title}') else: continue # 优先级过滤规则 if subscribe.best_version: priority_rule = self.systemconfig.get(SystemConfigKey.BestVersionFilterRules) else: priority_rule = self.systemconfig.get(SystemConfigKey.SubscribeFilterRules) result: List[TorrentInfo] = self.filter_torrents( rule_string=priority_rule, torrent_list=[torrent_info], mediainfo=torrent_mediainfo) if result is not None and not result: # 不符合过滤规则 logger.debug(f"{torrent_info.title} 不匹配当前过滤规则") continue # 不在订阅站点范围的不处理 sub_sites = self.get_sub_sites(subscribe) if sub_sites and torrent_info.site not in sub_sites: logger.debug(f"{torrent_info.site_name} - {torrent_info.title} 不符合订阅站点要求") continue # 如果是电视剧 if torrent_mediainfo.type == MediaType.TV: # 有多季的不要 if len(torrent_meta.season_list) > 1: logger.debug(f'{torrent_info.title} 有多季，不处理') continue # 比对季 if torrent_meta.begin_season: if meta.begin_season != torrent_meta.begin_season: logger.debug(f'{torrent_info.title} 季不匹配') continue elif meta.begin_season != 1: logger.debug(f'{torrent_info.title} 季不匹配') continue # 非洗版 if not subscribe.best_version: # 不是缺失的剧集不要 if no_exists and no_exists.get(mediakey): # 缺失集 no_exists_info = no_exists.get(mediakey).get(subscribe.season) if no_exists_info: # 是否有交集 if no_exists_info.episodes and \ torrent_meta.episode_list and \ not set(no_exists_info.episodes).intersection( set(torrent_meta.episode_list) ): logger.debug( f'{torrent_info.title} 对应剧集 {torrent_meta.episode_list} 未包含缺失的剧集' ) continue else: # 洗版时，非整季不要 if meta.type == MediaType.TV: if torrent_meta.episode_list: logger.debug(f'{subscribe.name} 正在洗版，{torrent_info.title} 不是整季') continue # 过滤规则 if not self.torrenthelper.filter_torrent(torrent_info=torrent_info, filter_rule=filter_rule, mediainfo=torrent_mediainfo): continue # 洗版时，优先级小于已下载优先级的不要 if subscribe.best_version: if subscribe.current_priority \ and torrent_info.pri_order <= subscribe.current_priority: logger.info(f'{subscribe.name} 正在洗版，{torrent_info.title} 优先级低于或等于已下载优先级') continue # 匹配成功 logger.info(f'{mediainfo.title_year} 匹配成功：{torrent_info.title}') _match_context.append(context) if not _match_context: # 未匹配到资源 logger.info(f'{mediainfo.title_year} 未匹配到符合条件的资源') self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo, lefts=no_exists) continue # 开始批量择优下载 logger.info(f'{mediainfo.title_year} 匹配完成，共匹配到{len(_match_context)}个资源') downloads, lefts = self.downloadchain.batch_download(contexts=_match_context, no_exists=no_exists, userid=subscribe.username, username=subscribe.username, save_path=subscribe.save_path) # 判断是否要完成订阅 self.finish_subscribe_or_not(subscribe=subscribe, meta=meta, mediainfo=mediainfo, downloads=downloads, lefts=lefts) def check(self): """ 定时检查订阅，更新订阅信息 """ # 查询所有订阅 subscribes = self.subscribeoper.list() if not subscribes: # 没有订阅不运行 return # 遍历订阅 for subscribe in subscribes: logger.info(f'开始更新订阅元数据：{subscribe.name} ...') # 生成元数据 meta = MetaInfo(subscribe.name) meta.year = subscribe.year meta.begin_season = subscribe.season or None try: meta.type = MediaType(subscribe.type) except ValueError: logger.error(f'订阅 {subscribe.name} 类型错误：{subscribe.type}') continue # 识别媒体信息 mediainfo: MediaInfo = self.recognize_media(meta=meta, mtype=meta.type, tmdbid=subscribe.tmdbid, doubanid=subscribe.doubanid, cache=False) if not mediainfo: logger.warn( f'未识别到媒体信息，标题：{subscribe.name}，tmdbid：{subscribe.tmdbid}，doubanid：{subscribe.doubanid}') continue # 对于电视剧，获取当前季的总集数 episodes = mediainfo.seasons.get(subscribe.season) or [] if not subscribe.manual_total_episode and len(episodes): total_episode = len(episodes) lack_episode = subscribe.lack_episode + (total_episode - subscribe.total_episode) logger.info( f'订阅 {subscribe.name} 总集数变化，更新总集数为{total_episode}，缺失集数为{lack_episode} ...') else: total_episode = subscribe.total_episode lack_episode = subscribe.lack_episode # 更新TMDB信息 self.subscribeoper.update(subscribe.id, { "name": mediainfo.title, "year": mediainfo.year, "vote": mediainfo.vote_average, "poster": mediainfo.get_poster_image(), "backdrop": mediainfo.get_backdrop_image(), "description": mediainfo.overview, "imdbid": mediainfo.imdb_id, "tvdbid": mediainfo.tvdb_id, "total_episode": total_episode, "lack_episode": lack_episode }) logger.info(f'{subscribe.name} 订阅元数据更新完成') def __update_subscribe_note(self, subscribe: Subscribe, downloads: List[Context]): """ 更新已下载集数到note字段 """ # 查询现有Note if not downloads: return note = [] if subscribe.note: try: note = json.loads(subscribe.note) except JSONDecodeError: note = [] 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: continue # 合并已下载集 note = list(set(note).union(set(episodes))) # 更新订阅 self.subscribeoper.update(subscribe.id, { "note": json.dumps(note) }) @staticmethod def __get_downloaded_episodes(subscribe: Subscribe) -> List[int]: """ 获取已下载过的集数 """ if not subscribe.note: return [] if subscribe.type != MediaType.TV.value: return [] try: episodes = json.loads(subscribe.note) logger.info(f'订阅 {subscribe.name} 第{subscribe.season}季 已下载集数：{episodes}') return episodes except JSONDecodeError: logger.warn(f'订阅 {subscribe.name} 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 }) def __finish_subscribe(self, subscribe: Subscribe, mediainfo: MediaInfo, meta: MetaBase, bestversion: bool = False): """ 完成订阅 """ # 完成订阅 msgstr = "订阅" if bestversion: msgstr = "洗版" logger.info(f'{mediainfo.title_year} 完成{msgstr}') # 新增订阅历史 self.subscribehistoryoper.add(**subscribe.to_dict()) # 删除订阅 self.subscribeoper.delete(subscribe.id) # 发送通知 if mediainfo.type == MediaType.TV: link = settings.MP_DOMAIN('#/subscribe/tv?tab=mysub') else: link = settings.MP_DOMAIN('#/subscribe/movie?tab=mysub') self.post_message(Notification(mtype=NotificationType.Subscribe, title=f'{mediainfo.title_year} {meta.season} 已完成{msgstr}', image=mediainfo.get_message_image(), link=link)) # 发送事件 EventManager().send_event(EventType.SubscribeComplete, { "subscribe_id": subscribe.id, "subscribe_info": subscribe.to_dict(), "mediainfo": mediainfo.to_dict(), }) # 统计订阅 self.subscribehelper.sub_done_async({ "tmdbid": mediainfo.tmdb_id, "doubanid": mediainfo.douban_id }) def remote_list(self, channel: MessageChannel, userid: Union[str, int] = None): """ 查询订阅并发送消息 """ subscribes = self.subscribeoper.list() if not subscribes: self.post_message(Notification(channel=channel, title='没有任何订阅！', userid=userid)) return title = f"共有 {len(subscribes)} 个订阅，回复对应指令操作： " \ f"\n- 删除订阅：/subscribe_delete [id]" \ f"\n- 搜索订阅：/subscribe_search [id]" \ f"\n- 刷新订阅：/subscribe_refresh" messages = [] for subscribe in subscribes: if subscribe.type == MediaType.MOVIE.value: messages.append(f"{subscribe.id}. {subscribe.name}（{subscribe.year}）") else: messages.append(f"{subscribe.id}. {subscribe.name}（{subscribe.year}）" f"第{subscribe.season}季 " f"[{subscribe.total_episode - (subscribe.lack_episode or subscribe.total_episode)}" f"/{subscribe.total_episode}]") # 发送列表 self.post_message(Notification(channel=channel, title=title, text='\n'.join(messages), userid=userid)) def remote_delete(self, arg_str: str, channel: MessageChannel, userid: Union[str, int] = None): """ 删除订阅 """ if not arg_str: self.post_message(Notification(channel=channel, title="请输入正确的命令格式：/subscribe_delete [id]，" "[id]为订阅编号", userid=userid)) return arg_strs = str(arg_str).split() for arg_str in arg_strs: arg_str = arg_str.strip() if not arg_str.isdigit(): continue subscribe_id = int(arg_str) subscribe = self.subscribeoper.get(subscribe_id) if not subscribe: self.post_message(Notification(channel=channel, title=f"订阅编号 {subscribe_id} 不存在！", userid=userid)) return # 删除订阅 self.subscribeoper.delete(subscribe_id) # 统计订阅 self.subscribehelper.sub_done_async({ "tmdbid": subscribe.tmdbid, "doubanid": subscribe.doubanid }) # 重新发送消息 self.remote_list(channel, userid) @staticmethod def __get_subscribe_no_exits(subscribe_name: str, no_exists: Dict[Union[int, str], Dict[int, NotExistMediaInfo]], mediakey: Union[str, int], begin_season: int, total_episode: int, start_episode: int, downloaded_episodes: List[int] = None): """ 根据订阅开始集数和总集数，结合TMDB信息计算当前订阅的缺失集数 :param subscribe_name: 订阅名称 :param no_exists: 缺失季集列表 :param mediakey: TMDB ID或豆瓣ID :param begin_season: 开始季 :param total_episode: 订阅设定总集数 :param start_episode: 订阅设定开始集数 :param downloaded_episodes: 已下载集数 """ # 使用订阅的总集数和开始集数替换no_exists if not no_exists or not no_exists.get(mediakey): return no_exists no_exists_item = no_exists.get(mediakey) if total_episode or start_episode: logger.info(f'订阅 {subscribe_name} 设定的开始集数：{start_episode}、总集数：{total_episode}') # 该季原缺失信息 no_exist_season = no_exists_item.get(begin_season) if no_exist_season: # 原集列表 episode_list = no_exist_season.episodes # 原总集数 total = no_exist_season.total_episode # 原开始集数 start = no_exist_season.start_episode # 更新剧集列表、开始集数、总集数 if not episode_list: # 整季缺失 episodes = [] start_episode = start_episode or start total_episode = total_episode or total else: # 部分缺失 if not start_episode \ and not total_episode: # 无需调整 return no_exists if not start_episode: # 没有自定义开始集 start_episode = start if not total_episode: # 没有自定义总集数 total_episode = total # 新的集列表 new_episodes = list(range(max(start_episode, start), total_episode + 1)) # 与原集列表取交集 episodes = list(set(episode_list).intersection(set(new_episodes))) # 更新集合 no_exists[mediakey][begin_season] = NotExistMediaInfo( season=begin_season, episodes=episodes, total_episode=total_episode, start_episode=start_episode ) # 根据订阅已下载集数更新缺失集数 if downloaded_episodes: logger.info(f'订阅 {subscribe_name} 已下载集数：{downloaded_episodes}') # 该季原缺失信息 no_exist_season = no_exists_item.get(begin_season) if no_exist_season: # 原集列表 episode_list = no_exist_season.episodes # 原总集数 total = no_exist_season.total_episode # 原开始集数 start = no_exist_season.start_episode # 整季缺失 if not episode_list: episode_list = list(range(start, total + 1)) # 更新剧集列表 episodes = list(set(episode_list).difference(set(downloaded_episodes))) # 更新集合 no_exists[mediakey][begin_season] = NotExistMediaInfo( season=begin_season, episodes=episodes, total_episode=total, start_episode=start ) else: # 开始集数 start = start_episode or 1 # 不存在的季 no_exists[mediakey][begin_season] = NotExistMediaInfo( season=begin_season, episodes=list(set(range(start, total_episode + 1)).difference(set(downloaded_episodes))), total_episode=total_episode, start_episode=start ) logger.info(f'订阅 {subscribe_name} 缺失剧集数更新为：{no_exists}') return no_exists @eventmanager.register(EventType.SiteDeleted) def remove_site(self, event: Event): """ 从订阅中移除与站点相关的设置 """ if not event: return event_data = event.event_data or {} site_id = event_data.get("site_id") if not site_id: return if site_id == "*": # 站点被重置 SystemConfigOper().set(SystemConfigKey.RssSites, []) for subscribe in self.subscribeoper.list(): if not subscribe.sites: continue self.subscribeoper.update(subscribe.id, { "sites": "" }) return # 从选中的rss站点中移除 selected_sites = SystemConfigOper().get(SystemConfigKey.RssSites) or [] if site_id in selected_sites: selected_sites.remove(site_id) SystemConfigOper().set(SystemConfigKey.RssSites, selected_sites) # 查询所有订阅 for subscribe in self.subscribeoper.list(): if not subscribe.sites: continue try: sites = json.loads(subscribe.sites) except JSONDecodeError: sites = [] if site_id not in sites: continue sites.remove(site_id) self.subscribeoper.update(subscribe.id, { "sites": json.dumps(sites) }) @staticmethod def __get_default_subscribe_config(mtype: MediaType, default_config_key: str): """ 获取默认订阅配置 """ default_subscribe_key = None if mtype == MediaType.TV: default_subscribe_key = "DefaultTvSubscribeConfig" if mtype == MediaType.MOVIE: default_subscribe_key = "DefaultMovieSubscribeConfig" # 默认订阅规则 if hasattr(settings, default_subscribe_key): value = getattr(settings, default_subscribe_key) else: value = SystemConfigOper().get(default_subscribe_key) if not value: return None return value.get(default_config_key) or None