feat(watchlist): implement Plex watchlist GraphQL API support

docs/using-seerr/plex/watchlist-auto-request.md

@@ -14,7 +14,10 @@ This feature is only available for Plex users. Local users cannot use the Watchl
 
 ## Prerequisites
 
-- You must have logged into Seerr at least once with your Plex account
+- You must have _one_ of the following
+  - You have logged into Seerr at least once with your Plex account
+  - You are Plex friends with your administrator and have kept the default setting to share your Plex Watchlist with friends
+  - You have your Plex Watchlist set to public
 - Your administrator must have granted you the necessary permissions
 - Your Plex account must have access to the Plex server configured in Seerr
 
@@ -57,6 +60,10 @@ Contact your administrator to verify you have been granted:
 - Seerr will automatically create requests for new items
 - You'll receive notifications when items are auto-requested
 
+:::warning Watchlist Inaccessible
+If you receive the error "User's watchlist is not accessible." when saving your settings at the end of Step 2, you have not fulfilled the first prerequisite.
+:::
+
 ## How It Works
 
 Once properly configured, Seerr will:
@@ -90,6 +97,6 @@ Auto-request only works for standard quality content. 4K content must be request
 
 - Local users cannot use this feature
 - 4K content requires manual requests
-- Users must have logged into Seerr with their Plex account
+- Users must have logged into Seerr with their Plex account or have made their watchlist accessible to their administrator's Plex account
 - Respects user request limits and quotas
 - Won't request content already in your libraries

server/api/plextv.ts

@@ -98,15 +98,37 @@
   };
 }
 
-interface WatchlistResponse {
+interface HomeUsersResponse {
   MediaContainer: {
-    totalSize: number;
-    Metadata?: {
-      ratingKey: string;
+    User: {
+      $: {
+        id: string;
+        uuid: string;
+        title: string;
+        username: string;
+        email: string;
+        thumb: string;
+      };
     }[];
   };
 }
 
+interface WatchlistResponse {
+  data?: {
+    user: {
+      watchlist: {
+        nodes: {
+          id: string;
+        }[];
+        pageInfo: {
+          hasNextPage: boolean;
+          endCursor: string;
+        };
+      };
+    };
+  } | null;
+}
+
 type PlexMetadataItem = {
   ratingKey: string;
   type: 'movie' | 'show';
@@ -115,6 +137,7 @@
     id: `imdb://tt${number}` | `tmdb://${number}` | `tvdb://${number}`;
   }[];
 };
+
 interface MetadataResponse {
   MediaContainer: {
     Metadata?: PlexMetadataItem[];
@@ -268,35 +291,65 @@
     return parsedXml;
   }
 
-  public async getWatchlist({
-    offset = 0,
-    size = 20,
-  }: { offset?: number; size?: number } = {}): Promise<{
-    offset: number;
-    size: number;
+  public async getHomeUsers(): Promise<HomeUsersResponse> {
+    const response = await this.axios.get('/api/home/users', {
+      transformResponse: [],
+      responseType: 'text',
+    });
+
+    const parsedXml = (await xml2js.parseStringPromise(
+      response.data
+    )) as HomeUsersResponse;
+    return parsedXml;
+  }
+
+  public async getWatchlist(
+    uuid: string,
+    {
+      first = 20,
+      after = undefined,
+    }: { first?: number; after?: string | undefined } = {}
+  ): Promise<{
+    first: number;
+    after: string | undefined;
+    endCursor: string | undefined;
     totalSize: number;
     items: PlexWatchlistItem[];
   }> {
     try {
       const watchlistCache = cacheManager.getCache('plexwatchlist');
-      let cachedWatchlist = watchlistCache.data.get<PlexWatchlistCache>(
-        this.authToken
-      );
+      let cachedWatchlist = watchlistCache.data.get<PlexWatchlistCache>(uuid);
 
-      const response = await this.axios.get<WatchlistResponse>(
-        '/library/sections/watchlist/all',
+      const response = await this.axios.post<WatchlistResponse>(
+        '/api',
         {
-          params: {
-            'X-Plex-Container-Start': offset,
-            'X-Plex-Container-Size': size,
-          },
-          headers: {
-            'If-None-Match': cachedWatchlist?.etag,
+          query: `query GetWatchlistHub($uuid: ID = "", $first: PaginationInt!, $after: String) {
+                      user(id: $uuid) {
+                          watchlist(first: $first, after: $after) {
+                              nodes {
+                                  ...itemFields
+                              }
+                              pageInfo {
+                                  hasNextPage
+                                  endCursor
+                              }
+                          }
+                      }
+                  }
+
+                  fragment itemFields on MetadataItem {
+                      id
+                  }`,
+          variables: {
+            uuid: uuid,
+            first: first,
+            after: after,
           },
-          baseURL: 'https://discover.provider.plex.tv',
-          validateStatus: (status) => status < 400, // Allow HTTP 304 to return without error
+        },
+        {
+          baseURL: 'https://community.plex.tv',
         }
       );
 
       // If we don't recieve HTTP 304, the watchlist has been updated and we need to update the cache.
       if (response.status >= 200 && response.status <= 299) {
@@ -305,27 +358,24 @@
           response: response.data,
         };
 
-        watchlistCache.data.set<PlexWatchlistCache>(
-          this.authToken,
-          cachedWatchlist
-        );
+        watchlistCache.data.set<PlexWatchlistCache>(uuid, cachedWatchlist);
       }
 
       const watchlistDetails = await Promise.all(
-        (cachedWatchlist?.response.MediaContainer.Metadata ?? []).map(
+        (cachedWatchlist?.response.data?.user.watchlist.nodes ?? []).map(
           async (watchlistItem) => {
             let detailedResponse: MetadataResponse;
             try {
               detailedResponse = await this.getRolling<MetadataResponse>(
-                `/library/metadata/${watchlistItem.ratingKey}`,
+                `/library/metadata/${watchlistItem.id}`,
                 {
                   baseURL: 'https://discover.provider.plex.tv',
                 }
               );
             } catch (e) {
               if (e.response?.status === 404) {
                 logger.warn(
-                  `Item with ratingKey ${watchlistItem.ratingKey} not found, it may have been removed from the server.`,
+                  `Item with id ${watchlistItem.id} not found, it may have been removed from the server.`,
                   { label: 'Plex.TV Metadata API' }
                 );
                 return null;
@@ -340,7 +390,7 @@
 
             if (!metadata) {
               logger.warn(
-                `Item with ratingKey ${watchlistItem.ratingKey} returned no metadata, skipping.`,
+                `Item with id ${watchlistItem.id} returned no metadata, skipping.`,
                 { label: 'Plex.TV Metadata API' }
               );
               return null;
@@ -373,9 +423,12 @@
       ) as PlexWatchlistItem[];
 
       return {
-        offset,
-        size,
-        totalSize: cachedWatchlist?.response.MediaContainer.totalSize ?? 0,
+        first,
+        after,
+        endCursor:
+          cachedWatchlist?.response.data?.user.watchlist.pageInfo.endCursor,
+        totalSize:
+          cachedWatchlist?.response.data?.user.watchlist.nodes.length ?? 0,
         items: filteredList,
       };
     } catch (e) {
@@ -384,8 +437,9 @@
         errorMessage: e.message,
       });
       return {
-        offset,
-        size,
+        first,
+        after,
+        endCursor: undefined,
         totalSize: 0,
         items: [],
       };

server/constants/error.ts

@@ -9,4 +9,5 @@ export enum ApiErrorCode {
   SyncErrorNoLibraries = 'SYNC_ERROR_NO_LIBRARIES',
   Unauthorized = 'UNAUTHORIZED',
   Unknown = 'UNKNOWN',
+  WatchlistAccessDenied = 'WATCHLIST_ACCESS_DENIED',
 }

server/entity/User.ts

@@ -43,6 +43,7 @@ export class User {
   static readonly filteredFields: string[] = [
     'email',
     'plexId',
+    'plexUuid',
     'password',
     'resetPasswordGuid',
     'jellyfinDeviceId',
@@ -89,6 +90,9 @@ export class User {
   @Column({ type: 'integer', nullable: true, select: true })
   public plexId?: number | null;
 
+  @Column({ type: 'varchar', nullable: true, select: false })
+  public plexUuid?: string | null;
+
   @Column({ type: 'varchar', nullable: true })
   public jellyfinUserId?: string | null;
 

server/lib/watchlistsync.ts

@@ -1,5 +1,6 @@
 import PlexTvAPI from '@server/api/plextv';
 import { MediaStatus, MediaType } from '@server/constants/media';
+import { UserType } from '@server/constants/user';
 import { getRepository } from '@server/datasource';
 import Media from '@server/entity/Media';
 import {
@@ -18,22 +19,62 @@ class WatchlistSync {
   public async syncWatchlist() {
     const userRepository = getRepository(User);
 
+    // Taken from auth.ts
+    const mainUser = await userRepository.findOneOrFail({
+      select: { id: true, plexToken: true },
+      where: { id: 1 },
+    });
+
+    // Old imported plex users may not have plex uuids stored in the db
+    const nullUsers = await userRepository
+      .createQueryBuilder('user')
+      .where('user.userType = :userType', { userType: UserType.PLEX })
+      .andWhere('user.plexUuid IS NULL')
+      .getMany();
+
+    if (nullUsers.length > 0) {
+      logger.warn(
+        'Found plex users without assigned uuids. Obtaining corresponding uuids.',
+        {
+          label: 'Plex Watchlist Sync',
+        }
+      );
+
+      const mainPlexTv = new PlexTvAPI(mainUser.plexToken ?? '');
+
+      const plexHomeUsersResponse = await mainPlexTv.getHomeUsers();
+      for (const rawUser of plexHomeUsersResponse.MediaContainer.User) {
+        const account = rawUser.$;
+
+        const user = await userRepository
+          .createQueryBuilder('user')
+          .where('user.plexId = :id', { id: account.id })
+          .getOne();
+
+        if (user) {
+          user.plexUuid = account.uuid;
+          await userRepository.save(user);
+        }
+      }
+    }
+
     // Get users who actually have plex tokens
     const users = await userRepository
       .createQueryBuilder('user')
       .addSelect('user.plexToken')
+      .addSelect('user.plexUuid')
       .leftJoinAndSelect('user.settings', 'settings')
-      .where("user.plexToken != ''")
+      .where('user.userType = :userType', { userType: UserType.PLEX })
       .getMany();
 
     for (const user of users) {
-      await this.syncUserWatchlist(user);
+      await this.syncUserWatchlist(user, mainUser.plexToken ?? '');
     }
   }
 
-  private async syncUserWatchlist(user: User) {
-    if (!user.plexToken) {
-      logger.warn('Skipping user watchlist sync for user without plex token', {
+  private async syncUserWatchlist(user: User, mainPlexToken: string) {
+    if (!user.plexUuid) {
+      logger.warn('Skipping user watchlist sync for user without plex uuid', {
         label: 'Plex Watchlist Sync',
         user: user.displayName,
       });
@@ -61,9 +102,30 @@ class WatchlistSync {
       return;
     }
 
-    const plexTvApi = new PlexTvAPI(user.plexToken);
+    // Token sync if the user has a token, else fallback to sync using the main user's token
+    const plexTvApi = user.plexToken
+      ? new PlexTvAPI(user.plexToken)
+      : new PlexTvAPI(mainPlexToken);
+
+    const response = await plexTvApi.getWatchlist(user.plexUuid);
+
+    // endCursor will be undefined if the GQL query fails to return Watchlist data
+    if (response.endCursor === undefined && user.settings) {
+      user.settings.watchlistSyncMovies = false;
+      user.settings.watchlistSyncTv = false;
 
-    const response = await plexTvApi.getWatchlist({ size: 20 });
+      const userRepository = getRepository(User);
+      await userRepository.save(user);
+
+      logger.warn(
+        'Disabling watchlist sync for user because access is denied',
+        {
+          label: 'Plex Watchlist Sync',
+          user: user.displayName,
+        }
+      );
+      return;
+    }
 
     const mediaItems = await Media.getRelatedMedia(
       user,

server/migration/postgres/1777262170937-AddPlexUuidToUser.ts

@@ -0,0 +1,15 @@
+import type { MigrationInterface, QueryRunner } from 'typeorm';
+
+export class AddPlexUuidToUser1777262170937 implements MigrationInterface {
+  name = 'AddPlexUuidToUser1777262170937';
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "user" ADD "plexUuid" character varying`
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(`ALTER TABLE "user" DROP COLUMN "plexUuid"`);
+  }
+}