feat(requests): Request Overrides & Request Editing (#653)

server/routes/index.ts

@@ -14,6 +14,7 @@ import mediaRoutes from './media';
 import personRoutes from './person';
 import collectionRoutes from './collection';
 import { getAppVersion, getCommitTag } from '../utils/appVersion';
+import serviceRoutes from './service';
 
 const router = Router();
 
@@ -45,6 +46,7 @@ router.use('/tv', isAuthenticated(), tvRoutes);
 router.use('/media', isAuthenticated(), mediaRoutes);
 router.use('/person', isAuthenticated(), personRoutes);
 router.use('/collection', isAuthenticated(), collectionRoutes);
+router.use('/service', isAuthenticated(), serviceRoutes);
 router.use('/auth', authRoutes);
 
 router.get('/', (_req, res) => {

server/routes/request.ts

@@ -199,6 +199,9 @@ requestRoutes.post(
               ? req.user
               : undefined,
           is4k: req.body.is4k,
+          serverId: req.body.serverId,
+          profileId: req.body.profileId,
+          rootFolder: req.body.rootFolder,
           seasons: finalSeasons.map(
             (sn) =>
               new SeasonRequest({
@@ -238,6 +241,102 @@ requestRoutes.get('/:requestId', async (req, res, next) => {
   }
 });
 
+requestRoutes.put<{ requestId: string }>(
+  '/:requestId',
+  isAuthenticated(Permission.MANAGE_REQUESTS),
+  async (req, res, next) => {
+    const requestRepository = getRepository(MediaRequest);
+    try {
+      const request = await requestRepository.findOne(
+        Number(req.params.requestId)
+      );
+
+      if (!request) {
+        return next({ status: 404, message: 'Request not found' });
+      }
+
+      if (req.body.mediaType === 'movie') {
+        request.serverId = req.body.serverId;
+        request.profileId = req.body.profileId;
+        request.rootFolder = req.body.rootFolder;
+
+        requestRepository.save(request);
+      } else if (req.body.mediaType === 'tv') {
+        const mediaRepository = getRepository(Media);
+        request.serverId = req.body.serverId;
+        request.profileId = req.body.profileId;
+        request.rootFolder = req.body.rootFolder;
+
+        const requestedSeasons = req.body.seasons as number[] | undefined;
+
+        if (!requestedSeasons || requestedSeasons.length === 0) {
+          throw new Error(
+            'Missing seasons. If you want to cancel a tv request, use the DELETE method.'
+          );
+        }
+
+        // Get existing media so we can work with all the requests
+        const media = await mediaRepository.findOneOrFail({
+          where: { tmdbId: request.media.tmdbId, mediaType: MediaType.TV },
+          relations: ['requests'],
+        });
+
+        // Get all requested seasons that are not part of this request we are editing
+        const existingSeasons = media.requests
+          .filter((r) => r.is4k === request.is4k && r.id !== request.id)
+          .reduce((seasons, r) => {
+            const combinedSeasons = r.seasons.map(
+              (season) => season.seasonNumber
+            );
+
+            return [...seasons, ...combinedSeasons];
+          }, [] as number[]);
+
+        const filteredSeasons = requestedSeasons.filter(
+          (rs) => !existingSeasons.includes(rs)
+        );
+
+        if (filteredSeasons.length === 0) {
+          return next({
+            status: 202,
+            message: 'No seasons available to request',
+          });
+        }
+
+        const newSeasons = requestedSeasons.filter(
+          (sn) => !request.seasons.map((s) => s.seasonNumber).includes(sn)
+        );
+
+        request.seasons = request.seasons.filter((rs) =>
+          filteredSeasons.includes(rs.seasonNumber)
+        );
+
+        if (newSeasons.length > 0) {
+          logger.debug('Adding new seasons to request', {
+            label: 'Media Request',
+            newSeasons,
+          });
+          request.seasons.push(
+            ...newSeasons.map(
+              (ns) =>
+                new SeasonRequest({
+                  seasonNumber: ns,
+                  status: MediaRequestStatus.PENDING,
+                })
+            )
+          );
+        }
+
+        await requestRepository.save(request);
+      }
+
+      return res.status(200).json(request);
+    } catch (e) {
+      next({ status: 500, message: e.message });
+    }
+  }
+);
+
 requestRoutes.delete('/:requestId', async (req, res, next) => {
   const requestRepository = getRepository(MediaRequest);
 

server/routes/service.ts

@@ -0,0 +1,148 @@
+import { Router } from 'express';
+import RadarrAPI from '../api/radarr';
+import SonarrAPI from '../api/sonarr';
+import {
+  ServiceCommonServer,
+  ServiceCommonServerWithDetails,
+} from '../interfaces/api/serviceInterfaces';
+import { getSettings } from '../lib/settings';
+
+const serviceRoutes = Router();
+
+serviceRoutes.get('/radarr', async (req, res) => {
+  const settings = getSettings();
+
+  const filteredRadarrServers: ServiceCommonServer[] = settings.radarr.map(
+    (radarr) => ({
+      id: radarr.id,
+      name: radarr.name,
+      is4k: radarr.is4k,
+      isDefault: radarr.isDefault,
+      activeDirectory: radarr.activeDirectory,
+      activeProfileId: radarr.activeProfileId,
+    })
+  );
+
+  return res.status(200).json(filteredRadarrServers);
+});
+
+serviceRoutes.get<{ radarrId: string }>(
+  '/radarr/:radarrId',
+  async (req, res, next) => {
+    const settings = getSettings();
+
+    const radarrSettings = settings.radarr.find(
+      (radarr) => radarr.id === Number(req.params.radarrId)
+    );
+
+    if (!radarrSettings) {
+      return next({
+        status: 404,
+        message: 'Radarr server with provided ID  does not exist.',
+      });
+    }
+
+    const radarr = new RadarrAPI({
+      apiKey: radarrSettings.apiKey,
+      url: `${radarrSettings.useSsl ? 'https' : 'http'}://${
+        radarrSettings.hostname
+      }:${radarrSettings.port}${radarrSettings.baseUrl ?? ''}/api`,
+    });
+
+    const profiles = await radarr.getProfiles();
+    const rootFolders = await radarr.getRootFolders();
+
+    return res.status(200).json({
+      server: {
+        id: radarrSettings.id,
+        name: radarrSettings.name,
+        is4k: radarrSettings.is4k,
+        isDefault: radarrSettings.isDefault,
+        activeDirectory: radarrSettings.activeDirectory,
+        activeProfileId: radarrSettings.activeProfileId,
+      },
+      profiles: profiles.map((profile) => ({
+        id: profile.id,
+        name: profile.name,
+      })),
+      rootFolders: rootFolders.map((folder) => ({
+        id: folder.id,
+        freeSpace: folder.freeSpace,
+        path: folder.path,
+        totalSpace: folder.totalSpace,
+      })),
+    } as ServiceCommonServerWithDetails);
+  }
+);
+
+serviceRoutes.get('/sonarr', async (req, res) => {
+  const settings = getSettings();
+
+  const filteredSonarrServers: ServiceCommonServer[] = settings.sonarr.map(
+    (sonarr) => ({
+      id: sonarr.id,
+      name: sonarr.name,
+      is4k: sonarr.is4k,
+      isDefault: sonarr.isDefault,
+      activeDirectory: sonarr.activeDirectory,
+      activeProfileId: sonarr.activeProfileId,
+      activeAnimeProfileId: sonarr.activeAnimeProfileId,
+      activeAnimeDirectory: sonarr.activeAnimeDirectory,
+    })
+  );
+
+  return res.status(200).json(filteredSonarrServers);
+});
+
+serviceRoutes.get<{ sonarrId: string }>(
+  '/sonarr/:sonarrId',
+  async (req, res, next) => {
+    const settings = getSettings();
+
+    const sonarrSettings = settings.sonarr.find(
+      (radarr) => radarr.id === Number(req.params.sonarrId)
+    );
+
+    if (!sonarrSettings) {
+      return next({
+        status: 404,
+        message: 'Radarr server with provided ID  does not exist.',
+      });
+    }
+
+    const sonarr = new SonarrAPI({
+      apiKey: sonarrSettings.apiKey,
+      url: `${sonarrSettings.useSsl ? 'https' : 'http'}://${
+        sonarrSettings.hostname
+      }:${sonarrSettings.port}${sonarrSettings.baseUrl ?? ''}/api`,
+    });
+
+    const profiles = await sonarr.getProfiles();
+    const rootFolders = await sonarr.getRootFolders();
+
+    return res.status(200).json({
+      server: {
+        id: sonarrSettings.id,
+        name: sonarrSettings.name,
+        is4k: sonarrSettings.is4k,
+        isDefault: sonarrSettings.isDefault,
+        activeDirectory: sonarrSettings.activeDirectory,
+        activeProfileId: sonarrSettings.activeProfileId,
+        activeAnimeProfileId: sonarrSettings.activeAnimeProfileId,
+        activeAnimeDirectory: sonarrSettings.activeAnimeDirectory,
+      },
+      profiles: profiles.map((profile) => ({
+        id: profile.id,
+        name: profile.name,
+      })),
+      rootFolders: rootFolders.map((folder) => ({
+        id: folder.id,
+        freeSpace: folder.freeSpace,
+        path: folder.path,
+        totalSpace: folder.totalSpace,
+      })),
+    } as ServiceCommonServerWithDetails);
+  }
+);
+
+export default serviceRoutes;