✨ Add NZBGet download client

src/pages/api/modules/usenet/history.ts

@@ -7,6 +7,8 @@ import { UsenetHistoryItem } from '../../../../modules';
 import { getConfig } from '../../../../tools/getConfig';
 import { getServiceById } from '../../../../tools/hooks/useGetServiceByType';
 import { Config } from '../../../../tools/types';
+import { NzbgetHistoryItem } from './nzbget/types';
+import { NzbgetClient } from './nzbget/nzbget-client';
 
 dayjs.extend(duration);
 
@@ -33,23 +35,72 @@ async function Get(req: NextApiRequest, res: NextApiResponse) {
       throw new Error(`Service with ID "${req.query.serviceId}" could not be found.`);
     }
 
-    if (!service.apiKey) {
-      throw new Error(`API Key for service "${service.name}" is missing`);
+    let response: UsenetHistoryResponse;
+    switch (service.type) {
+      case 'NZBGet': {
+        const url = new URL(service.url);
+        const options = {
+          host: url.hostname,
+          port: url.port,
+          login: service.username,
+          hash: service.password,
+        };
+
+        const nzbGet = NzbgetClient(options);
+
+        const nzbgetHistory:NzbgetHistoryItem[] = await new Promise((resolve, reject) => {
+          nzbGet.history(false, (err: any, result: NzbgetHistoryItem[]) => {
+            if (!err) {
+              resolve(result);
+            } else {
+              reject(err);
+            }
+          });
+        });
+
+        if (!nzbgetHistory) {
+          throw new Error('Error while getting NZBGet history');
+        }
+
+        const nzbgetItems: UsenetHistoryItem[] = nzbgetHistory.map((item: NzbgetHistoryItem) => ({
+          id: item.NZBID.toString(),
+          name: item.Name,
+          // Convert from MB to bytes
+          size: item.DownloadedSizeMB * 1000000,
+          time: item.DownloadTimeSec,
+        }));
+
+        response = {
+          items: nzbgetItems,
+          total: nzbgetItems.length,
+        };
+        break;
+      }
+      case 'Sabnzbd': {
+        const { origin } = new URL(service.url);
+
+        if (!service.apiKey) {
+          throw new Error(`API Key for service "${service.name}" is missing`);
+        }
+
+        const history = await new Client(origin, service.apiKey).history(offset, limit);
+
+        const items: UsenetHistoryItem[] = history.slots.map((slot) => ({
+          id: slot.nzo_id,
+          name: slot.name,
+          size: slot.bytes,
+          time: slot.download_time,
+        }));
+
+        response = {
+          items,
+          total: history.noofslots,
+        };
+        break;
+      }
+      default:
+        throw new Error(`Service type "${service.type}" unrecognized.`);
     }
-    const { origin } = new URL(service.url);
-
-    const history = await new Client(origin, service.apiKey).history(offset, limit);
-
-    const items: UsenetHistoryItem[] = history.slots.map((slot) => ({
-      id: slot.nzo_id,
-      name: slot.name,
-      size: slot.bytes,
-      time: slot.download_time,
-    }));
-    const response: UsenetHistoryResponse = {
-      items,
-      total: history.noofslots,
-    };
 
     return res.status(200).json(response);
   } catch (err) {

src/pages/api/modules/usenet/index.ts

@@ -6,6 +6,8 @@ import { Client } from 'sabnzbd-api';
 import { getConfig } from '../../../../tools/getConfig';
 import { getServiceById } from '../../../../tools/hooks/useGetServiceByType';
 import { Config } from '../../../../tools/types';
+import { NzbgetStatus } from './nzbget/types';
+import { NzbgetClient } from './nzbget/nzbget-client';
 
 dayjs.extend(duration);
 
@@ -32,28 +34,71 @@ async function Get(req: NextApiRequest, res: NextApiResponse) {
       throw new Error(`Service with ID "${req.query.serviceId}" could not be found.`);
     }
 
-    if (!service.apiKey) {
-      throw new Error(`API Key for service "${service.name}" is missing`);
+    let response: UsenetInfoResponse;
+    switch (service.type) {
+      case 'NZBGet': {
+        const url = new URL(service.url);
+        const options = {
+          host: url.hostname,
+          port: url.port,
+          login: service.username,
+          hash: service.password,
+        };
+
+        const nzbGet = NzbgetClient(options);
+
+        const nzbgetStatus:NzbgetStatus = await new Promise((resolve, reject) => {
+          nzbGet.status((err: any, result: NzbgetStatus) => {
+            if (!err) {
+              resolve(result);
+            } else {
+              reject(err);
+            }
+          });
+        });
+
+        if (!nzbgetStatus) {
+          throw new Error('Error while getting NZBGet status');
+        }
+
+        const bytesRemaining = nzbgetStatus.RemainingSizeMB * 1000000;
+        const eta = bytesRemaining / nzbgetStatus.DownloadRate;
+        response = {
+          paused: nzbgetStatus.DownloadPaused,
+          sizeLeft: bytesRemaining,
+          speed: nzbgetStatus.DownloadRate,
+          eta,
+        };
+        break;
+      }
+      case 'Sabnzbd': {
+        if (!service.apiKey) {
+          throw new Error(`API Key for service "${service.name}" is missing`);
+        }
+
+        const { origin } = new URL(service.url);
+
+        const queue = await new Client(origin, service.apiKey).queue(0, -1);
+
+        const [hours, minutes, seconds] = queue.timeleft.split(':');
+        const eta = dayjs.duration({
+          hour: parseInt(hours, 10),
+          minutes: parseInt(minutes, 10),
+          seconds: parseInt(seconds, 10),
+        } as any);
+
+        response = {
+          paused: queue.paused,
+          sizeLeft: parseFloat(queue.mbleft) * 1024 * 1024,
+          speed: parseFloat(queue.kbpersec) * 1000,
+          eta: eta.asSeconds(),
+        };
+        break;
+      }
+      default:
+        throw new Error(`Service type "${service.type}" unrecognized.`);
     }
 
-    const { origin } = new URL(service.url);
-
-    const queue = await new Client(origin, service.apiKey).queue(0, -1);
-
-    const [hours, minutes, seconds] = queue.timeleft.split(':');
-    const eta = dayjs.duration({
-      hour: parseInt(hours, 10),
-      minutes: parseInt(minutes, 10),
-      seconds: parseInt(seconds, 10),
-    } as any);
-
-    const response: UsenetInfoResponse = {
-      paused: queue.paused,
-      sizeLeft: parseFloat(queue.mbleft) * 1024 * 1024,
-      speed: parseFloat(queue.kbpersec) * 1000,
-      eta: eta.asSeconds(),
-    };
-
     return res.status(200).json(response);
   } catch (err) {
     return res.status(500).send((err as any).message);

src/pages/api/modules/usenet/nzbget/nzbget-api.d.ts

@@ -0,0 +1 @@
+declare module 'nzbget-api';

src/pages/api/modules/usenet/nzbget/nzbget-client.ts

@@ -0,0 +1,22 @@
+import NZBGet from 'nzbget-api';
+import { NzbgetClientOptions } from './types';
+
+export function NzbgetClient(options: NzbgetClientOptions) {
+    if (!options?.host) {
+        throw new Error('Cannot connect to NZBGet. Missing host in service config.');
+    }
+
+    if (!options?.port) {
+        throw new Error('Cannot connect to NZBGet. Missing port in service config.');
+    }
+
+    if (!options?.login) {
+        throw new Error('Cannot connect to NZBGet. Missing username in service config.');
+    }
+
+    if (!options?.hash) {
+        throw new Error('Cannot connect to NZBGet. Missing password in service config.');
+    }
+
+    return new NZBGet(options);
+}

src/pages/api/modules/usenet/nzbget/types.ts

@@ -0,0 +1,135 @@
+export interface NzbgetHistoryItem {
+  NZBID: number;
+  Kind: 'NZB' | 'URL' | 'DUP';
+  NZBFilename: string;
+  Name: string;
+  URL: string;
+  HistoryTime: number;
+  DestDir: string;
+  FinalDir: string;
+  Category: string;
+  FileSizeLo: number;
+  FileSizeHi: number;
+  FileSizeMB: number;
+  FileCount: number;
+  RemainingFileCount: number;
+  MinPostTime: number;
+  MaxPostTime: number;
+  TotalArticles: number;
+  SuccessArticles: number;
+  FailedArticles: number;
+  Health: number;
+  DownloadedSizeLo: number;
+  DownloadedSizeHi: number;
+  DownloadedSizeMB: number;
+  DownloadTimeSec: number;
+  PostTotalTimeSec: number;
+  ParTimeSec: number;
+  RepairTimeSec: number
+  UnpackTimeSec: number;
+  MessageCount:number;
+  DupeKey: string;
+  DupeScore: number;
+  DupeMode: 'SCORE' | 'ALL' | 'FORCE';
+  Status: string;
+  ParStatus: 'NONE' | 'FAILURE' | 'REPAIR_POSSIBLE' | 'SUCCESS' | 'MANUAL';
+  ExParStatus: 'RECIPIENT' | 'DONOR';
+  UnpackStatus: 'NONE' | 'FAILURE' | 'SPACE' | 'PASSWORD' | 'SUCCESS';
+  UrlStatus: 'NONE' | 'SUCCESS' | 'FAILURE' | 'SCAN_SKIPPED' | 'SCAN_FAILURE';
+  ScriptStatus: 'NONE' | 'FAILURE' | 'SUCCESS';
+  ScriptStatuses: [];
+  MoveStatus: 'NONE' | 'SUCCESS' | 'FAILURE';
+  DeleteStatus: 'NONE' | 'MANUAL' | 'HEALTH' | 'DUPE' | 'BAD' | 'SCAN' | 'COPY';
+  MarkStatus: 'NONE' | 'GOOD' | 'BAD';
+  ExtraParBlocks: number;
+  Parameters: [];
+  ServerStats: [];
+}
+
+export interface NzbgetQueueItem {
+  NZBID: number;
+  NZBFilename: string;
+  NZBName: string;
+  Kind: 'NZB' | 'URL';
+  URL: string;
+  DestDir: string;
+  FinalDir: string;
+  Category: string;
+  FileSizeLo: number;
+  FileSizeHi: number;
+  FileSizeMB: number;
+  RemainingSizeLo: number;
+  RemainingSizeHi: number;
+  RemainingSizeMB: number;
+  PausedSizeLo: number;
+  PausedSizeHi: number;
+  PausedSizeMB: number;
+  FileCount: number;
+  RemainingFileCount: number;
+  RemainingParCount: number;
+  MinPostTime: number;
+  MaxPostTime: number;
+  MaxPriority: number;
+  ActiveDownloads: number;
+  Status: 'QUEUED' | 'PAUSED' | 'DOWNLOADING' | 'FETCHING' | 'PP_QUEUED' | 'LOADING_PARS' | 'VERIFYING_SOURCES' | 'REPAIRING' | 'VERIFYING_REPAIRED' | 'RENAMING' | 'UNPACKING' | 'MOVING' | 'EXECUTING_SCRIPT' | 'PP_FINISHED';
+  TotalArticles: number;
+  SuccessArticles: number;
+  FailedArticles: number;
+  Health: number;
+  CriticalHealth: number;
+  DownloadedSizeLo: number;
+  DownloadedSizeHi: number;
+  DownloadedSizeMB: number;
+  DownloadTimeSec: number;
+  MessageCount: number;
+  DupeKey: string;
+  DupeScore: number;
+  DupeMode: string;
+  Parameters: [];
+  ServerStats: [];
+  PostInfoText: string;
+  PostStageProgress: number;
+  PostTotalTimeSec: number;
+  PostStageTimeSec: number;
+}
+
+export interface NzbgetStatus {
+  RemainingSizeLo: number;
+  RemainingSizeHi: number;
+  RemainingSizeMB: number;
+  ForcedSizeLo: number;
+  ForcedSizeHi: number;
+  ForcedSizeMB: number;
+  DownloadedSizeLo: number;
+  DownloadedSizeHi: number;
+  DownloadedSizeMB: number;
+  ArticleCacheLo: number;
+  ArticleCacheHi: number;
+  ArticleCacheMB: number;
+  DownloadRate: number;
+  AverageDownloadRate: number;
+  DownloadLimit: number;
+  ThreadCount: number;
+  PostJobCount: number;
+  UrlCount: number;
+  UpTimeSec: number;
+  DownloadTimeSec: number;
+  ServerStandBy: boolean;
+  DownloadPaused: boolean;
+  PostPaused: boolean;
+  ScanPaused: boolean;
+  ServerTime: number;
+  ResumeTime: number;
+  FeedActive: boolean;
+  FreeDiskSpaceLo: number;
+  FreeDiskSpaceHi: number;
+  FreeDiskSpaceMB: number;
+  NewsServers: [];
+}
+
+export interface NzbgetClientOptions {
+  host: string,
+  port: string,
+  login: string | undefined,
+  hash: string | undefined,
+}

src/pages/api/modules/usenet/pause.ts

@@ -6,6 +6,7 @@ import { Client } from 'sabnzbd-api';
 import { getConfig } from '../../../../tools/getConfig';
 import { getServiceById } from '../../../../tools/hooks/useGetServiceByType';
 import { Config } from '../../../../tools/types';
+import { NzbgetClient } from './nzbget/nzbget-client';
 
 dayjs.extend(duration);
 
@@ -25,14 +26,44 @@ async function Post(req: NextApiRequest, res: NextApiResponse) {
       throw new Error(`Service with ID "${req.query.serviceId}" could not be found.`);
     }
 
-    if (!service.apiKey) {
-      throw new Error(`API Key for service "${service.name}" is missing`);
+    let result;
+    switch (service.type) {
+      case 'NZBGet': {
+        const url = new URL(service.url);
+        const options = {
+          host: url.hostname,
+          port: url.port,
+          login: service.username,
+          hash: service.password,
+        };
+
+        const nzbGet = NzbgetClient(options);
+
+        result = await new Promise((resolve, reject) => {
+          nzbGet.pauseDownload(false, (err: any, result: any) => {
+            if (!err) {
+              resolve(result);
+            } else {
+              reject(err);
+            }
+          });
+        });
+        break;
+      }
+      case 'Sabnzbd': {
+        if (!service.apiKey) {
+          throw new Error(`API Key for service "${service.name}" is missing`);
+        }
+
+        const { origin } = new URL(service.url);
+
+        result = await new Client(origin, service.apiKey).queuePause();
+        break;
+      }
+      default:
+        throw new Error(`Service type "${service.type}" unrecognized.`);
     }
 
-    const { origin } = new URL(service.url);
-
-    const result = await new Client(origin, service.apiKey).queuePause();
-
     return res.status(200).json(result);
   } catch (err) {
     return res.status(500).send((err as any).message);

src/pages/api/modules/usenet/queue.ts

@@ -7,6 +7,8 @@ import { UsenetQueueItem } from '../../../../modules';
 import { getConfig } from '../../../../tools/getConfig';
 import { getServiceById } from '../../../../tools/hooks/useGetServiceByType';
 import { Config } from '../../../../tools/types';
+import { NzbgetClient } from './nzbget/nzbget-client';
+import { NzbgetQueueItem, NzbgetStatus } from './nzbget/types';
 
 dayjs.extend(duration);
 
@@ -33,42 +35,116 @@ async function Get(req: NextApiRequest, res: NextApiResponse) {
       throw new Error(`Service with ID "${req.query.serviceId}" could not be found.`);
     }
 
-    if (!service.apiKey) {
-      throw new Error(`API Key for service "${service.name}" is missing`);
+    let response: UsenetQueueResponse;
+    switch (service.type) {
+      case 'NZBGet': {
+        const url = new URL(service.url);
+        const options = {
+          host: url.hostname,
+          port: url.port,
+          login: service.username,
+          hash: service.password,
+        };
+
+        const nzbGet = NzbgetClient(options);
+
+        const nzbgetQueue:NzbgetQueueItem[] = await new Promise((resolve, reject) => {
+          nzbGet.listGroups((err: any, result: NzbgetQueueItem[]) => {
+            if (!err) {
+              resolve(result);
+            } else {
+              reject(err);
+            }
+          });
+        });
+
+        if (!nzbgetQueue) {
+          throw new Error('Error while getting NZBGet queue');
+        }
+
+        const nzbgetStatus:NzbgetStatus = await new Promise((resolve, reject) => {
+          nzbGet.status((err: any, result: NzbgetStatus) => {
+            if (!err) {
+              resolve(result);
+            } else {
+              reject(err);
+            }
+          });
+        });
+
+        if (!nzbgetStatus) {
+          throw new Error('Error while getting NZBGet status');
+        }
+
+        const nzbgetItems: UsenetQueueItem[] = nzbgetQueue.map((item: NzbgetQueueItem) => ({
+          id: item.NZBID.toString(),
+          name: item.NZBName,
+          progress: (item.DownloadedSizeMB / item.FileSizeMB) * 100,
+          eta: (item.RemainingSizeMB * 1000000) / nzbgetStatus.DownloadRate,
+          // Multiple MB to get bytes
+          size: item.FileSizeMB * 1000 * 1000,
+          state: getNzbgetState(item.Status),
+        }));
+
+        response = {
+          items: nzbgetItems,
+          total: nzbgetItems.length,
+        };
+        break;
+      }
+      case 'Sabnzbd': {
+        if (!service.apiKey) {
+          throw new Error(`API Key for service "${service.name}" is missing`);
+        }
+
+        const { origin } = new URL(service.url);
+        const queue = await new Client(origin, service.apiKey).queue(offset, limit);
+
+        const items: UsenetQueueItem[] = queue.slots.map((slot) => {
+          const [hours, minutes, seconds] = slot.timeleft.split(':');
+          const eta = dayjs.duration({
+            hour: parseInt(hours, 10),
+            minutes: parseInt(minutes, 10),
+            seconds: parseInt(seconds, 10),
+          } as any);
+
+          return {
+            id: slot.nzo_id,
+            eta: eta.asSeconds(),
+            name: slot.filename,
+            progress: parseFloat(slot.percentage),
+            size: parseFloat(slot.mb) * 1000 * 1000,
+            state: slot.status.toLowerCase() as any,
+          };
+        });
+
+        response = {
+          items,
+          total: queue.noofslots,
+        };
+        break;
+      }
+      default:
+        throw new Error(`Service type "${service.type}" unrecognized.`);
     }
 
-    const { origin } = new URL(service.url);
-    const queue = await new Client(origin, service.apiKey).queue(offset, limit);
-
-    const items: UsenetQueueItem[] = queue.slots.map((slot) => {
-      const [hours, minutes, seconds] = slot.timeleft.split(':');
-      const eta = dayjs.duration({
-        hour: parseInt(hours, 10),
-        minutes: parseInt(minutes, 10),
-        seconds: parseInt(seconds, 10),
-      } as any);
-
-      return {
-        id: slot.nzo_id,
-        eta: eta.asSeconds(),
-        name: slot.filename,
-        progress: parseFloat(slot.percentage),
-        size: parseFloat(slot.mb) * 1000 * 1000,
-        state: slot.status.toLowerCase() as any,
-      };
-    });
-
-    const response: UsenetQueueResponse = {
-      items,
-      total: queue.noofslots,
-    };
-
     return res.status(200).json(response);
   } catch (err) {
     return res.status(500).send((err as any).message);
   }
 }
 
+function getNzbgetState(status: string) {
+  switch (status) {
+    case 'QUEUED':
+      return 'queued';
+    case 'PAUSED ':
+        return 'paused';
+    default:
+      return 'downloading';
+  }
+}
+
 export default async (req: NextApiRequest, res: NextApiResponse) => {
   // Filter out if the reuqest is a POST or a GET
   if (req.method === 'GET') {

src/pages/api/modules/usenet/resume.ts

@@ -6,6 +6,7 @@ import { Client } from 'sabnzbd-api';
 import { getConfig } from '../../../../tools/getConfig';
 import { getServiceById } from '../../../../tools/hooks/useGetServiceByType';
 import { Config } from '../../../../tools/types';
+import { NzbgetClient } from './nzbget/nzbget-client';
 
 dayjs.extend(duration);
 
@@ -26,14 +27,44 @@ async function Post(req: NextApiRequest, res: NextApiResponse) {
       throw new Error(`Service with ID "${req.query.serviceId}" could not be found.`);
     }
 
-    if (!service.apiKey) {
-      throw new Error(`API Key for service "${service.name}" is missing`);
+    let result;
+    switch (service.type) {
+      case 'NZBGet': {
+        const url = new URL(service.url);
+        const options = {
+          host: url.hostname,
+          port: url.port,
+          login: service.username,
+          hash: service.password,
+        };
+
+        const nzbGet = NzbgetClient(options);
+
+        result = await new Promise((resolve, reject) => {
+          nzbGet.resumeDownload(false, (err: any, result: any) => {
+            if (!err) {
+              resolve(result);
+            } else {
+              reject(err);
+            }
+          });
+        });
+        break;
+      }
+      case 'Sabnzbd': {
+        if (!service.apiKey) {
+          throw new Error(`API Key for service "${service.name}" is missing`);
+        }
+
+        const { origin } = new URL(service.url);
+
+        result = await new Client(origin, service.apiKey).queueResume();
+        break;
+      }
+      default:
+        throw new Error(`Service type "${service.type}" unrecognized.`);
     }
 
-    const { origin } = new URL(service.url);
-
-    const result = await new Client(origin, service.apiKey).queueResume();
-
     return res.status(200).json(result);
   } catch (err) {
     return res.status(500).send((err as any).message);