feat: catalogue server side filters

backend/src/user-data/library/library.service.ts

@@ -6,33 +6,17 @@ import {
 } from 'src/common/common.dto';
 import { MetadataService } from 'src/metadata/metadata.service';
 import { Repository } from 'typeorm';
-import { LibraryItemDto } from './library.dto';
+import {
+  LibraryItemDto,
+  MyListSortBy,
+  MyListFilter,
+  SortByDirection,
+} from './library.dto';
 import { LibraryItem } from './library.entity';
 import { USER_LIBRARY_REPOSITORY } from './library.providers';
-
-export enum SortByDirection {
-  Asc = 'asc',
-  Desc = 'desc',
-}
-
-export enum LibrarySortBy {
-  DateAdded = 'dateAdded',
-  Name = 'name',
-  FirstReleaseDate = 'firstReleaseDate',
-  LastReleaseDate = 'lastReleaseDate',
-}
-
-export enum MyListFilter {
-  Movie = 'movie',
-  Series = 'series',
-}
-
-export enum CatalogueFilter {
-  All = 'all',
-  Movies = 'movies',
-  Series = 'series',
-  Unavailable = 'unavailable',
-}
+import { SourceProvidersService } from 'src/source-providers/source-providers.service';
+import { MediaSourcesService } from 'src/users/media-sources/media-sources.service';
+import { PlayState } from '../play-state/play-state.entity';
 
 @Injectable()
 export class LibraryService {
@@ -40,41 +24,15 @@ export class LibraryService {
     @Inject(USER_LIBRARY_REPOSITORY)
     private readonly libraryRepository: Repository<LibraryItem>,
     private readonly metadataService: MetadataService,
+    private readonly mediaSourceService: MediaSourcesService,
   ) {}
 
-  async getMyListDtos(
-    ...args: Parameters<LibraryService['getMyList']>
-  ): Promise<PaginatedResponseDto<LibraryItemDto>> {
-    const paginatedItems = await this.getMyList(...args);
-
-    const items = await Promise.all(
-      paginatedItems.items.map(async (item) => {
-        const seriesMetadata =
-          item.mediaType === MediaType.Series
-            ? await this.metadataService.getSeriesByTmdbId(item.tmdbId)
-            : undefined;
-        const movieMetadata =
-          item.mediaType === MediaType.Movie
-            ? await this.metadataService.getMovieByTmdbId(item.tmdbId)
-            : undefined;
-
-        return LibraryItemDto.create({
-          libraryItem: item,
-          seriesMetadata,
-          movieMetadata,
-        });
-      }),
-    );
-
-    return { ...paginatedItems, items };
-  }
-
   /** TODO: decouple librayItem and movie/seriesItem */
-  private async getMyList(options: {
+  async getMyList(options: {
     userId: string;
     pagination: PaginationParamsDto;
     filter?: MyListFilter;
-    sortBy?: LibrarySortBy;
+    sortBy?: MyListSortBy;
     direction?: SortByDirection;
   }): Promise<PaginatedResponseDto<LibraryItem>> {
     const {
@@ -88,8 +46,8 @@ export class LibraryService {
     const directon = direction === SortByDirection.Asc ? 'ASC' : 'DESC';
 
     const order = {
-      [LibrarySortBy.DateAdded]: { createdAt: directon } as const,
-      [LibrarySortBy.Name]: {
+      [MyListSortBy.DateAdded]: { createdAt: directon } as const,
+      [MyListSortBy.Name]: {
         seriesMetadata: {
           name: directon,
         },
@@ -97,7 +55,7 @@ export class LibraryService {
           name: directon,
         },
       } as const,
-      [LibrarySortBy.FirstReleaseDate]: {
+      [MyListSortBy.FirstReleaseDate]: {
         movieMetadata: {
           releaseDate: directon,
         },
@@ -105,7 +63,7 @@ export class LibraryService {
           firstReleaseDate: directon,
         },
       } as const,
-      [LibrarySortBy.LastReleaseDate]: {
+      [MyListSortBy.LastReleaseDate]: {
         movieMetadata: {
           releaseDate: directon,
         },
@@ -156,6 +114,115 @@ export class LibraryService {
     };
   }
 
+  async getCatalogueItems<T extends object = object>(options: {
+    sourceId: string;
+    token: string;
+    pagination: PaginationParamsDto;
+    filter?: 'all' | 'movies' | 'series' | 'missing';
+  }): Promise<PaginatedResponseDto<LibraryItemDto> | undefined> {
+    const { sourceId, token, pagination, filter = 'all' } = options;
+
+    const connection = await this.mediaSourceService.getConnection(sourceId);
+
+    if (!connection) return;
+
+    const combined = connection.provider.catalogueProvider.getCatalogue;
+    const movies = connection.provider.catalogueProvider.getMovieCatalogue;
+    const series = connection.provider.catalogueProvider.getSeriesCatalogue;
+    const missing = connection.provider.catalogueProvider.getMissingInCatalogue;
+    if (filter === 'all' && combined) {
+      const response = await combined(
+        {
+          userId: connection.mediaSource.userId,
+          settings: connection.mediaSource.pluginSettings,
+          sourceId: connection.mediaSource.id,
+          token,
+        },
+        pagination,
+      );
+
+      return {
+        ...response,
+        items: await Promise.all(
+          response.items.map(async (item) => this.getLibraryItemDto(item)),
+        ),
+      };
+    } else if (filter === 'movies' && movies) {
+      const response = await movies(
+        {
+          userId: connection.mediaSource.userId,
+          settings: connection.mediaSource.pluginSettings,
+          sourceId: connection.mediaSource.id,
+          token,
+        },
+        pagination,
+      );
+
+      return {
+        ...response,
+        items: await Promise.all(
+          response.items.map(async (item) => this.getLibraryItemDto(item)),
+        ),
+      };
+    } else if (filter === 'series' && series) {
+      const response = await series(
+        {
+          userId: connection.mediaSource.userId,
+          settings: connection.mediaSource.pluginSettings,
+          sourceId: connection.mediaSource.id,
+          token,
+        },
+        pagination,
+      );
+
+      return {
+        ...response,
+        items: await Promise.all(
+          response.items.map(async (item) => this.getLibraryItemDto(item)),
+        ),
+      };
+    } else if (filter === 'missing' && missing) {
+      const tmdbIdToMyListItem: Record<string, LibraryItem> = {};
+      const myListItems = await this.getMyList({
+        pagination: {
+          itemsPerPage: 500,
+          page: 1,
+        },
+        userId: connection.mediaSource.userId,
+        filter: MyListFilter.All,
+        sortBy: MyListSortBy.DateAdded,
+      }).then((res) => res.items);
+
+      myListItems.forEach((i) => {
+        tmdbIdToMyListItem[i.tmdbId] = i;
+      });
+
+      const response = await missing(
+        {
+          userId: connection.mediaSource.userId,
+          settings: connection.mediaSource.pluginSettings,
+          sourceId: connection.mediaSource.id,
+          token,
+        },
+        pagination,
+        tmdbIdToMyListItem,
+      );
+
+      return {
+        ...response,
+        items: await Promise.all(
+          response.items.map(async (item) =>
+            this.getLibraryItemDto({
+              ...item,
+              mediaType:
+                item.mediaType === MediaType.Movie ? 'movie' : 'series',
+            }),
+          ),
+        ),
+      };
+    }
+  }
+
   async findByTmdbId(
     userId: string,
     tmdbId: string,
@@ -185,4 +252,72 @@ export class LibraryService {
   async deleteByTmdbId(userId: string, tmdbId: string) {
     return await this.libraryRepository.delete({ userId, tmdbId });
   }
+
+  async getLibraryItemDto(options: {
+    tmdbId: string;
+    mediaType: 'series' | 'movie';
+    playStates?: PlayState[];
+  }): Promise<LibraryItemDto> {
+    const { tmdbId, mediaType, playStates } = options;
+
+    const seriesMetadata =
+      mediaType === 'series'
+        ? await this.metadataService.getSeriesByTmdbId(tmdbId)
+        : undefined;
+    const movieMetadata =
+      mediaType === 'movie'
+        ? await this.metadataService.getMovieByTmdbId(tmdbId)
+        : undefined;
+
+    if (!movieMetadata && !seriesMetadata) {
+      throw new Error(
+        'At least one of movieMetadata or seriesMetadata must be provided',
+      );
+    }
+
+    let watched = false;
+
+    if (mediaType === 'movie') {
+      watched = playStates?.some((state) => state.watched) ?? false;
+    } else if (
+      mediaType === 'series' &&
+      seriesMetadata?.tmdbSeries?.last_episode_to_air
+    ) {
+      const { season_number: season, episode_number: episode } =
+        seriesMetadata?.tmdbSeries.last_episode_to_air;
+      watched =
+        playStates?.some(
+          (state) =>
+            state.season === season &&
+            state.episode === episode &&
+            state.watched,
+        ) ?? false;
+    }
+
+    const libraryItem: LibraryItemDto = {
+      tmdbId,
+      mediaType: mediaType === 'movie' ? MediaType.Movie : MediaType.Series,
+      watched,
+      playStates,
+      tmdbItem: {
+        id: movieMetadata?.tmdbMovie.id ?? seriesMetadata?.tmdbSeries.id,
+        poster_path:
+          movieMetadata?.tmdbMovie.poster_path ??
+          seriesMetadata?.tmdbSeries.poster_path,
+        vote_average:
+          movieMetadata?.tmdbMovie.vote_average ??
+          seriesMetadata?.tmdbSeries.vote_average,
+        title: movieMetadata?.tmdbMovie.title,
+        release_date: movieMetadata?.tmdbMovie.release_date,
+        runtime: movieMetadata?.tmdbMovie.runtime,
+        name: seriesMetadata?.tmdbSeries.name,
+        first_air_date: seriesMetadata?.tmdbSeries.first_air_date,
+        last_air_date: seriesMetadata?.tmdbSeries.last_air_date,
+        next_episode_to_air: seriesMetadata?.tmdbSeries.next_episode_to_air,
+        seasons: seriesMetadata?.tmdbSeries.seasons,
+      },
+    };
+
+    return libraryItem;
+  }
 }