fix(requests): stop editing a request from re-requesting covered seasons

Creating a request skips seasons the media already has, but editing one
only looked at seasons held by other requests, so an edit could add a
season that was already available and charge the owner's quota for it.

The availability check applies to seasons being added, not to the ones the
request already holds, otherwise editing an approved request would drop its
own seasons the moment they started processing. The quota arithmetic now
counts the seasons the edit actually ends up with rather than assuming that
is every season it asked for.

Author: fallenbagel

server/routes/request.test.ts

@@ -9,6 +9,7 @@ import {
 import { getRepository } from '@server/datasource';
 import Media from '@server/entity/Media';
 import { MediaRequest } from '@server/entity/MediaRequest';
+import Season from '@server/entity/Season';
 import SeasonRequest from '@server/entity/SeasonRequest';
 import { User } from '@server/entity/User';
 import { getSettings } from '@server/lib/settings';
@@ -243,6 +244,19 @@ async function seedTvMedia(tmdbId: number) {
   );
 }
 
+async function seedMediaSeasons(
+  tmdbId: number,
+  seasons: { seasonNumber: number; status: MediaStatus }[]
+) {
+  const media = await seedTvMedia(tmdbId);
+  media.seasons = seasons.map(
+    ({ seasonNumber, status }) =>
+      new Season({ seasonNumber, status, status4k: MediaStatus.UNKNOWN })
+  );
+
+  return getRepository(Media).save(media);
+}
+
 async function seedTvRequest(
   requestedBy: User,
   seasons: number[],
@@ -303,6 +317,102 @@ describe('PUT /request/:requestId (tv)', () => {
   });
 });
 
+describe('PUT /request/:requestId (season availability)', () => {
+  it('does not add a season the media already has', async () => {
+    const requestRepo = getRepository(MediaRequest);
+    const owner = await seedUser('friend@seerr.dev');
+    const mediaRequest = await seedTvRequest(owner, [1]);
+    await seedMediaSeasons(67890, [
+      { seasonNumber: 2, status: MediaStatus.AVAILABLE },
+    ]);
+
+    const agent = await loginAs('friend@seerr.dev', 'test1234');
+    const res = await agent.put(`/request/${mediaRequest.id}`).send({
+      mediaType: MediaType.TV,
+      seasons: [1, 2, 3],
+    });
+
+    assert.strictEqual(res.status, 200);
+
+    const saved = await requestRepo.findOneOrFail({
+      where: { id: mediaRequest.id },
+    });
+    assert.deepStrictEqual(
+      saved.seasons.map((s) => s.seasonNumber).sort(),
+      [1, 3]
+    );
+  });
+
+  it('returns 202 when every requested season is already covered', async () => {
+    const owner = await seedUser('friend@seerr.dev');
+    const mediaRequest = await seedTvRequest(owner, [1]);
+    await seedMediaSeasons(67890, [
+      { seasonNumber: 2, status: MediaStatus.AVAILABLE },
+    ]);
+
+    const agent = await loginAs('friend@seerr.dev', 'test1234');
+    const res = await agent.put(`/request/${mediaRequest.id}`).send({
+      mediaType: MediaType.TV,
+      seasons: [2],
+    });
+
+    assert.strictEqual(res.status, 202);
+  });
+
+  it('keeps the seasons it already holds once they are available', async () => {
+    const requestRepo = getRepository(MediaRequest);
+    const owner = await seedUser('friend@seerr.dev');
+    const mediaRequest = await seedTvRequest(owner, [1, 2]);
+    await seedMediaSeasons(67890, [
+      { seasonNumber: 1, status: MediaStatus.AVAILABLE },
+      { seasonNumber: 2, status: MediaStatus.PROCESSING },
+    ]);
+
+    const agent = await loginAs('friend@seerr.dev', 'test1234');
+    const res = await agent.put(`/request/${mediaRequest.id}`).send({
+      mediaType: MediaType.TV,
+      seasons: [1, 2],
+      serverId: 3,
+    });
+
+    assert.strictEqual(res.status, 200);
+
+    const saved = await requestRepo.findOneOrFail({
+      where: { id: mediaRequest.id },
+    });
+    assert.deepStrictEqual(
+      saved.seasons.map((s) => s.seasonNumber).sort(),
+      [1, 2]
+    );
+    assert.strictEqual(saved.serverId, 3);
+  });
+
+  it('does not charge quota for a season the media already has', async () => {
+    const requestRepo = getRepository(MediaRequest);
+    const owner = await seedUser('friend@seerr.dev', { tvQuotaLimit: 1 });
+    const mediaRequest = await seedTvRequest(owner, [1]);
+    await seedMediaSeasons(67890, [
+      { seasonNumber: 2, status: MediaStatus.AVAILABLE },
+    ]);
+
+    const agent = await loginAs('friend@seerr.dev', 'test1234');
+    const res = await agent.put(`/request/${mediaRequest.id}`).send({
+      mediaType: MediaType.TV,
+      seasons: [1, 2],
+    });
+
+    assert.strictEqual(res.status, 200);
+
+    const saved = await requestRepo.findOneOrFail({
+      where: { id: mediaRequest.id },
+    });
+    assert.deepStrictEqual(
+      saved.seasons.map((s) => s.seasonNumber),
+      [1]
+    );
+  });
+});
+
 describe('PUT /request/:requestId (quota)', () => {
   it('rejects adding seasons beyond the season limit', async () => {
     const requestRepo = getRepository(MediaRequest);

server/routes/request.ts

@@ -594,25 +594,47 @@ requestRoutes.put<{ requestId: string }>(
                 return [...seasons, ...combinedSeasons];
               }, [] as number[]);
 
+            const currentSeasons = request.seasons.map((s) => s.seasonNumber);
+
+            // Seasons the media already covers cannot be requested again, while
+            // the ones this request holds stay on it
+            const coveredSeasons = (media.seasons ?? [])
+              .filter(
+                (season) =>
+                  season[request.is4k ? 'status4k' : 'status'] !==
+                    MediaStatus.UNKNOWN &&
+                  season[request.is4k ? 'status4k' : 'status'] !==
+                    MediaStatus.DELETED
+              )
+              .map((season) => season.seasonNumber)
+              .filter((sn) => !currentSeasons.includes(sn));
+
             const filteredSeasons = requestedSeasons.filter(
               (rs) => !existingSeasons.includes(rs)
             );
 
-            if (filteredSeasons.length === 0) {
+            const keptSeasons = filteredSeasons.filter((sn) =>
+              currentSeasons.includes(sn)
+            );
+
+            const newSeasons = filteredSeasons.filter(
+              (sn) =>
+                !currentSeasons.includes(sn) && !coveredSeasons.includes(sn)
+            );
+
+            const resultingSeasonCount = keptSeasons.length + newSeasons.length;
+
+            if (resultingSeasonCount === 0) {
               return next({
                 status: 202,
                 message: 'No seasons available to request',
               });
             }
 
-            const newSeasons = filteredSeasons.filter(
-              (sn) => !request.seasons.map((s) => s.seasonNumber).includes(sn)
-            );
-
             // The seasons this request already holds are counted in the owner's
             // usage, so they only need paying for again on reassignment
             const priorSeasonCount = ownerChanging ? 0 : request.seasons.length;
-            const requiredSeasons = filteredSeasons.length - priorSeasonCount;
+            const requiredSeasons = resultingSeasonCount - priorSeasonCount;
 
             if (!request.ignoreQuota && requiredSeasons > 0) {
               const quotas = await requestUser.getQuota();
@@ -629,7 +651,7 @@ requestRoutes.put<{ requestId: string }>(
             }
 
             request.seasons = request.seasons.filter((rs) =>
-              filteredSeasons.includes(rs.seasonNumber)
+              keptSeasons.includes(rs.seasonNumber)
             );
 
             if (newSeasons.length > 0) {