Merge pull request #145 from Gabisonfire/hotfix/series_consumer

Fix series parsing

src/node/consumer/src/lib/services/metadata_service.ts

@@ -141,9 +141,9 @@ export class MetadataService implements IMetadataService {
                 ? body.meta.videos.map(video => ({
                     name: video.name,
                     season: video.season,
-                    episode: video.episode,
+                    episode: video.number,
                     imdbSeason: video.season,
-                    imdbEpisode: video.episode,
+                    imdbEpisode: video.number,
                 }))
                 : [],
             episodeCount: body.meta?.videos
@@ -204,13 +204,13 @@ export class MetadataService implements IMetadataService {
 
     private getIMDbIdFromNameToImdb = (name: string, info: IMetaDataQuery): Promise<string | Error> => {
         const {year} = info;
-        const {type} = info;
+        const type = info.type === TorrentType.Movie ? 'movie' : 'series';
         return new Promise((resolve, reject) => {
-            nameToImdb({name, year, type}, function (err: Error, res: string) {
+            nameToImdb({name, year, type}, function (err: Error | null, res: string) {
                 if (res) {
                     resolve(res);
                 } else {
-                    reject(err || new Error('Failed IMDbId search'));
+                    reject(err || new Error('Failed to get IMDb id from name-to-imdb'));
                 }
             });
         });

src/node/consumer/src/lib/services/torrent_entries_service.ts

@@ -86,12 +86,15 @@ export class TorrentEntriesService implements ITorrentEntriesService {
             contents: fileCollection.contents,
             subtitles: fileCollection.subtitles
         });
+        
+        newTorrent.type = newTorrent.type.toLowerCase();
 
         return this.repository.createTorrent(newTorrent)
             .then(() => PromiseHelpers.sequence(fileCollection.videos!.map(video => () => {
                 const newVideo: IFileCreationAttributes = {...video, infoHash: video.infoHash, title: video.title};
                 if (!newVideo.kitsuId) {
                     newVideo.kitsuId = 0;
+                    newVideo.kitsuEpisode = 0;
                 }
                 return this.repository.createFile(newVideo)
             })))

src/node/consumer/src/lib/services/torrent_file_service.ts

@@ -57,11 +57,6 @@ export class TorrentFileService implements ITorrentFileService {
             return Promise.reject(new Error('Failed to retrieve metadata'));
         }
 
-        if (torrent.type !== TorrentType.Anime && metadata && metadata.type && metadata.type !== torrent.type) {
-            // it's actually a movie/series
-            torrent.type = metadata.type;
-        }
-
         if (torrent.type === TorrentType.Movie && (!parsedTorrentName.seasons ||
             parsedTorrentName.season === 5 && [1, 5].includes(parsedTorrentName.episode || 0))) {
             return this.parseMovieFiles(torrent, metadata);
@@ -195,6 +190,10 @@ export class TorrentFileService implements ITorrentFileService {
                     title: file.path || file.title,
                     size: file.size,
                     imdbId: torrent?.imdbId?.toString() || file?.imdbId?.toString() || '',
+                    kitsuId: torrent?.kitsuId || file.kitsuId || 0,
+                    imdbSeason: file.imdbSeason,
+                    imdbEpisode: file.imdbEpisode,
+                    kitsuEpisode: file.kitsuEpisode,
                 }]);
             }
             return Promise.resolve([]);
@@ -206,11 +205,11 @@ export class TorrentFileService implements ITorrentFileService {
             title: file.path || file.title,
             size: file.size,
             imdbId: file?.imdbId?.toString() || torrent?.imdbId?.toString() || '',
-            imdbSeason: file.season,
+            imdbSeason: file.imdbSeason,
             season: file.season,
             imdbEpisode: file.episodes && file.episodes[index],
             episode: file.episodes && file.episodes[index],
-            kitsuEpisode: file.episodes && file.episodes[index],
+            kitsuEpisode: file.kitsuId && file.kitsuId !== 0 && file.episodes && file.episodes[index],
             episodes: file.episodes,
             kitsuId: parseInt(file.kitsuId?.toString() || torrent.kitsuId?.toString() || '0') || 0,
         })))
@@ -493,13 +492,21 @@ export class TorrentFileService implements ITorrentFileService {
                     const episodeMapping = seasonMapping && file && file.episodes && file.episodes[0] && seasonMapping[file.episodes[0]] || null;
 
                     if (episodeMapping && Number.isInteger(episodeMapping.season)) {
-                        file.imdbId = metadata.imdbId?.toString();
+                        file.imdbId = metadata.imdbId?.toString() !== "NaN" ? metadata.imdbId?.toString() : file.imdbId;
                         file.season = episodeMapping.season;
                         file.episodes = file.episodes && file.episodes.map(ep => (seasonMapping && seasonMapping[ep]) ? Number(seasonMapping[ep].episode) : 0);
                     } else {
-                        file.season = undefined;
                         file.episodes = undefined;
                     }
+
+                    if (file.imdbId && file.season && file.episodes?.length > 0 && file.imdbEpisode === undefined && file.episode === undefined) {
+                        file.imdbEpisode = file.episodes[0];
+                        file.episode = file.episodes[0];
+                        file.imdbSeason = file.season;
+                    }
+
+                    this.patchMissingImdbValues(file);
+                    this.patchMissingKitsuValues(file);
                 });
         } else if (metadata.videos.some(video => video.episode)) {
             // imdb episode info is base
@@ -512,7 +519,7 @@ export class TorrentFileService implements ITorrentFileService {
                     if (seriesMapping[file.season]) {
 
                         const seasonMapping = seriesMapping[file.season];
-                        file.imdbId = metadata.imdbId?.toString();
+                        file.imdbId = metadata.imdbId?.toString() !== "NaN" ? metadata.imdbId?.toString() : file.imdbId;
                         file.kitsuId = seasonMapping[file.episodes[0]] && parseInt(seasonMapping[file.episodes[0]].id || '0') || 0;
                         file.episodes = file.episodes.map(ep => seasonMapping[ep]?.episode)
                             .filter((ep): ep is number => ep !== undefined);
@@ -532,7 +539,7 @@ export class TorrentFileService implements ITorrentFileService {
                         if (differentTitlesCount >= 1 && (isAbsoluteOrder || isNormalOrder)) {
                             const {season} = file;
                             const [episode] = file.episodes;
-                            file.imdbId = metadata.imdbId?.toString();
+                            file.imdbId = metadata.imdbId?.toString() !== "NaN" ? metadata.imdbId?.toString() : file.imdbId;
                             file.season = file.season - 1;
                             file.episodes = file.episodes.map(ep => isAbsoluteOrder ? ep : ep + skippedCount);
                             const currentEpisode = seriesMapping[season][episode];
@@ -549,17 +556,35 @@ export class TorrentFileService implements ITorrentFileService {
                         // sometimes series might be named with sequel season but it's not a season on imdb and a new title
                         // eslint-disable-next-line prefer-destructuring
                         const seasonMapping = seriesMapping[1];
-                        file.imdbId = metadata.imdbId?.toString();
+                        file.imdbId = metadata.imdbId?.toString() !== "NaN" ? metadata.imdbId?.toString() : file.imdbId;
                         file.season = 1;
                         file.kitsuId = parseInt(seasonMapping[file.episodes[0]].id || '0') || 0;
                         file.episodes = file.episodes.map(ep => seasonMapping[ep] && seasonMapping[ep].episode)
                             .filter((ep): ep is number => ep !== undefined);
                     }
+
+                    this.patchMissingImdbValues(file);
+                    this.patchMissingKitsuValues(file);
                 });
         }
         return files;
     };
 
+    private patchMissingKitsuValues = (file: IFileAttributes) : void => {
+        if (file.kitsuId !== 0 && file.kitsuId !== undefined && file.season && file.episodes?.length > 0 && file.imdbEpisode === undefined && file.episode === undefined) {
+            file.kitsuEpisode = file.episodes[0];
+            file.episode = file.episodes[0];
+        }
+    };
+
+    private patchMissingImdbValues = (file: IFileAttributes) : void => {
+        if (file.imdbId && file.season && file.episodes?.length > 0 && file.imdbEpisode === undefined && file.episode === undefined) {
+            file.imdbEpisode = file.episodes[0];
+            file.episode = file.episodes[0];
+            file.imdbSeason = file.season;
+        }
+    };
+
     private needsCinemetaMetadataForAnime = (files: IFileAttributes[], metadata: IMetadataResponse): boolean => {
         if (!metadata || !metadata.imdbId || !metadata.videos || !metadata.videos.length) {
             return false;
@@ -649,7 +674,7 @@ export class TorrentFileService implements ITorrentFileService {
     private isFeaturette = (video: IFileAttributes): boolean => /featurettes?\/|extras-grym/i.test(video.path!);
 
     private parseSeriesVideo = (video: IFileAttributes): IFileAttributes => {
-        const videoInfo = parse(video.title);
+        const videoInfo = parse(video.path);
         // the episode may be in a folder containing season number
         if (!Number.isInteger(videoInfo.season) && video.path?.includes('/')) {
             const folders = video.path?.split('/');
@@ -691,7 +716,17 @@ export class TorrentFileService implements ITorrentFileService {
             videoInfo.episode = videoInfo.episodes && videoInfo.episodes[0];
         }
 
-        return {...video, ...videoInfo};
+        let response : IFileAttributes = {...video, ...videoInfo};
+        
+        if (video.imdbId && video.imdbId !== "0") {
+            response = {...response, imdbEpisode: videoInfo.episode, imdbSeason: videoInfo.season};
+        }
+
+        if (video.kitsuId && video.kitsuId !== 0) {
+            response = {...response, kitsuEpisode: videoInfo.episode};
+        }
+        
+        return response;
     };
 
     private isMovieVideo = (torrent: IParsedTorrent, video: IFileAttributes, otherVideos: IFileAttributes[], hasMovies: boolean): boolean => {

src/node/consumer/src/lib/services/torrent_subtitle_service.ts

@@ -41,7 +41,7 @@ export class TorrentSubtitleService implements ITorrentSubtitleService {
         return Object.assign(video, {
             fileName: fileName,
             folderName: folderName,
-            ...this.parseFilename(video.title.toString() || '')
+            ...this.parseFilename(video.path || '')
         });
     }