feat(frontend): recently added on discover

also improves modal requests by not waiting for result from radarr/sonarr

server/entity/MediaRequest.ts

@@ -151,7 +151,8 @@ export class MediaRequest {
         });
         const movie = await tmdb.getMovie({ movieId: this.media.tmdbId });
 
-        await radarr.addMovie({
+        // Run this asynchronously so we don't wait for it on the UI side
+        radarr.addMovie({
           profileId: radarrSettings.activeProfileId,
           qualityProfileId: radarrSettings.activeProfileId,
           rootFolderPath: radarrSettings.activeDirectory,
@@ -212,7 +213,8 @@ export class MediaRequest {
           throw new Error('Series was missing tvdb id');
         }
 
-        await sonarr.addSeries({
+        // Run this asynchronously so we don't wait for it on the UI side
+        sonarr.addSeries({
           profileId: sonarrSettings.activeProfileId,
           rootFolderPath: sonarrSettings.activeDirectory,
           title: series.name,

server/routes/index.ts

@@ -10,6 +10,7 @@ import discoverRoutes from './discover';
 import requestRoutes from './request';
 import movieRoutes from './movie';
 import tvRoutes from './tv';
+import mediaRoutes from './media';
 
 const router = Router();
 
@@ -25,6 +26,7 @@ router.use('/discover', isAuthenticated(), discoverRoutes);
 router.use('/request', isAuthenticated(), requestRoutes);
 router.use('/movie', isAuthenticated(), movieRoutes);
 router.use('/tv', isAuthenticated(), tvRoutes);
+router.use('/media', isAuthenticated(), mediaRoutes);
 router.use('/auth', authRoutes);
 
 router.get('/settings/public', (_req, res) => {

server/routes/media.ts

@@ -0,0 +1,71 @@
+import { Router } from 'express';
+import { getRepository, FindOperator } from 'typeorm';
+import Media from '../entity/Media';
+import { MediaStatus } from '../constants/media';
+
+export interface MediaResultsResponse {
+  pageInfo: {
+    pages: number;
+    page: number;
+    results: number;
+    pageSize: number;
+  };
+  results: Media[];
+}
+
+const mediaRoutes = Router();
+
+mediaRoutes.get('/', async (req, res, next) => {
+  const mediaRepository = getRepository(Media);
+
+  const pageSize = Number(req.query.take) ?? 20;
+  const skip = Number(req.query.skip) ?? 0;
+
+  let statusFilter:
+    | MediaStatus
+    | FindOperator<MediaStatus>
+    | undefined = undefined;
+
+  switch (req.query.filter) {
+    case 'available':
+      statusFilter = MediaStatus.AVAILABLE;
+      break;
+    case 'partial':
+      statusFilter = MediaStatus.PARTIALLY_AVAILABLE;
+      break;
+    case 'processing':
+      statusFilter = MediaStatus.PROCESSING;
+      break;
+    case 'pending':
+      statusFilter = MediaStatus.PENDING;
+      break;
+    default:
+      statusFilter = undefined;
+  }
+
+  try {
+    const [media, mediaCount] = await mediaRepository.findAndCount({
+      order: {
+        id: 'DESC',
+      },
+      where: {
+        status: statusFilter,
+      },
+      take: pageSize,
+      skip,
+    });
+    return res.status(200).json({
+      pageInfo: {
+        pages: Math.ceil(mediaCount / pageSize),
+        pageSize,
+        results: mediaCount,
+        page: Math.ceil(skip / pageSize) + 1,
+      },
+      results: media,
+    } as MediaResultsResponse);
+  } catch (e) {
+    next({ status: 500, message: e.message });
+  }
+});
+
+export default mediaRoutes;

server/routes/request.ts

@@ -20,7 +20,8 @@ requestRoutes.get('/', async (req, res, next) => {
             id: 'DESC',
           },
           relations: ['media'],
-          take: 20,
+          take: Number(req.query.take) ?? 20,
+          skip: Number(req.query.skip) ?? 0,
         })
       : await requestRepository.find({
           where: { requestedBy: { id: req.user?.id } },
@@ -28,7 +29,8 @@ requestRoutes.get('/', async (req, res, next) => {
           order: {
             id: 'DESC',
           },
-          take: 20,
+          take: Number(req.query.limit) ?? 20,
+          skip: Number(req.query.skip) ?? 0,
         });
 
     return res.status(200).json(requests);