Merge remote-tracking branch 'origin/main'

app/modules/emby/__init__.py

@@ -68,7 +68,7 @@ class EmbyModule(_ModuleBase):
                 if movie:
                     logger.info(f"媒体库中已存在：{movie}")
                     return ExistMediaInfo(type=MediaType.MOVIE)
-            movies = self.emby.get_movies(title=mediainfo.title, year=mediainfo.year)
+            movies = self.emby.get_movies(title=mediainfo.title, year=mediainfo.year, tmdb_id=mediainfo.tmdb_id)
             if not movies:
                 logger.info(f"{mediainfo.title_year} 在媒体库中不存在")
                 return None

app/modules/emby/emby.py

@@ -272,11 +272,15 @@ class Emby(metaclass=Singleton):
             return None
         return ""
 
-    def get_movies(self, title: str, year: str = None) -> Optional[List[dict]]:
+    def get_movies(self, 
+                   title: str, 
+                   year: str = None,
+                   tmdb_id: int = None) -> Optional[List[dict]]:
         """
         根据标题和年份，检查电影是否在Emby中存在，存在则返回列表
         :param title: 标题
         :param year: 年份，可以为空，为空时不按年份过滤
+        :param tmdb_id: TMDB ID
         :return: 含title、year属性的字典列表
         """
         if not self._host or not self._apikey:
@@ -291,11 +295,19 @@ class Emby(metaclass=Singleton):
                 if res_items:
                     ret_movies = []
                     for res_item in res_items:
+                        item_tmdbid = res_item.get("ProviderIds", {}).get("Tmdb")
+                        if tmdb_id and item_tmdbid:
+                            if str(item_tmdbid) != str(tmdb_id):
+                                continue
+                            else:
+                                ret_movies.append(
+                                    {'title': res_item.get('Name'), 'year': str(res_item.get('ProductionYear'))})
+                                continue
                         if res_item.get('Name') == title and (
                                 not year or str(res_item.get('ProductionYear')) == str(year)):
                             ret_movies.append(
                                 {'title': res_item.get('Name'), 'year': str(res_item.get('ProductionYear'))})
-                            return ret_movies
+                    return ret_movies
         except Exception as e:
             logger.error(f"连接Items出错：" + str(e))
             return None

app/modules/jellyfin/__init__.py

@@ -64,7 +64,7 @@ class JellyfinModule(_ModuleBase):
                 if movie:
                     logger.info(f"媒体库中已存在：{movie}")
                     return ExistMediaInfo(type=MediaType.MOVIE)
-            movies = self.jellyfin.get_movies(title=mediainfo.title, year=mediainfo.year)
+            movies = self.jellyfin.get_movies(title=mediainfo.title, year=mediainfo.year, tmdb_id=mediainfo.tmdb_id)
             if not movies:
                 logger.info(f"{mediainfo.title_year} 在媒体库中不存在")
                 return None

app/modules/jellyfin/jellyfin.py

@@ -248,11 +248,15 @@ class Jellyfin(metaclass=Singleton):
             return None
         return ""
 
-    def get_movies(self, title: str, year: str = None) -> Optional[List[dict]]:
+    def get_movies(self, 
+                   title: str, 
+                   year: str = None,
+                   tmdb_id: int = None) -> Optional[List[dict]]:
         """
         根据标题和年份，检查电影是否在Jellyfin中存在，存在则返回列表
         :param title: 标题
         :param year: 年份，为空则不过滤
+        :param tmdb_id: TMDB ID
         :return: 含title、year属性的字典列表
         """
         if not self._host or not self._apikey or not self.user:
@@ -266,11 +270,19 @@ class Jellyfin(metaclass=Singleton):
                 if res_items:
                     ret_movies = []
                     for res_item in res_items:
+                        item_tmdbid = res_item.get("ProviderIds", {}).get("Tmdb")
+                        if tmdb_id and item_tmdbid:
+                            if str(item_tmdbid) != str(tmdb_id):
+                                continue
+                            else:
+                                ret_movies.append(
+                                    {'title': res_item.get('Name'), 'year': str(res_item.get('ProductionYear'))})
+                                continue
                         if res_item.get('Name') == title and (
                                 not year or str(res_item.get('ProductionYear')) == str(year)):
                             ret_movies.append(
                                 {'title': res_item.get('Name'), 'year': str(res_item.get('ProductionYear'))})
-                            return ret_movies
+                    return ret_movies
         except Exception as e:
             logger.error(f"连接Items出错：" + str(e))
             return None

app/modules/plex/__init__.py

@@ -54,7 +54,7 @@ class PlexModule(_ModuleBase):
                 if movie:
                     logger.info(f"媒体库中已存在：{movie}")
                     return ExistMediaInfo(type=MediaType.MOVIE)
-            movies = self.plex.get_movies(title=mediainfo.title, year=mediainfo.year)
+            movies = self.plex.get_movies(title=mediainfo.title, year=mediainfo.year, tmdb_id=mediainfo.tmdb_id)
             if not movies:
                 logger.info(f"{mediainfo.title_year} 在媒体库中不存在")
                 return None
@@ -64,6 +64,7 @@ class PlexModule(_ModuleBase):
         else:
             tvs = self.plex.get_tv_episodes(title=mediainfo.title,
                                             year=mediainfo.year,
+                                            tmdb_id=mediainfo.tmdb_id,
                                             item_id=itemid)
             if not tvs:
                 logger.info(f"{mediainfo.title_year} 在媒体库中不存在")

app/modules/plex/plex.py

@@ -128,11 +128,15 @@ class Plex(metaclass=Singleton):
             "EpisodeCount": EpisodeCount
         }
 
-    def get_movies(self, title: str, year: str = None) -> Optional[List[dict]]:
+    def get_movies(self, 
+                   title: str, 
+                   year: str = None,
+                   tmdb_id: int = None) -> Optional[List[dict]]:
         """
         根据标题和年份，检查电影是否在Plex中存在，存在则返回列表
         :param title: 标题
         :param year: 年份，为空则不过滤
+        :param tmdb_id: TMDB ID
         :return: 含title、year属性的字典列表
         """
         if not self._plex:
@@ -143,6 +147,10 @@ class Plex(metaclass=Singleton):
         else:
             movies = self._plex.library.search(title=title, libtype="movie")
         for movie in movies:
+            movie_tmdbid = self.__get_ids(movie.guids).get("tmdb_id")
+            if tmdb_id and movie_tmdbid:
+                if str(movie_tmdbid) != str(tmdb_id):
+                    continue
             ret_movies.append({'title': movie.title, 'year': movie.year})
         return ret_movies
 
@@ -150,12 +158,14 @@ class Plex(metaclass=Singleton):
                         item_id: str = None,
                         title: str = None,
                         year: str = None,
+                        tmdb_id: int = None,
                         season: int = None) -> Optional[Dict[int, list]]:
         """
         根据标题、年份、季查询电视剧所有集信息
         :param item_id: 媒体ID
         :param title: 标题
         :param year: 年份，可以为空，为空时不按年份过滤
+        :param tmdb_id: TMDB ID
         :param season: 季号，数字
         :return: 所有集的列表
         """
@@ -164,13 +174,17 @@ class Plex(metaclass=Singleton):
         if item_id:
             videos = self._plex.fetchItem(item_id)
         else:
+            # 根据标题和年份模糊搜索，该结果不够准确
             videos = self._plex.library.search(title=title, year=year, libtype="show")
         if not videos:
             return {}
         if isinstance(videos, list):
-            episodes = videos[0].episodes()
+            videos = videos[0]
-        else:
+        video_tmdbid = self.__get_ids(videos.guids).get('tmdb_id')
-            episodes = videos.episodes()
+        if tmdb_id and video_tmdbid:
+            if str(video_tmdbid) != str(tmdb_id):
+                return {}
+        episodes = videos.episodes()
         season_episodes = {}
         for episode in episodes:
             if season and episode.seasonNumber != int(season):