98 lines
3.6 KiB
JavaScript
98 lines
3.6 KiB
JavaScript
// Copyright (c) 2026 Gordon Bolton. MIT License.
|
||
//
|
||
// Shared helpers for assembling the cached *arr queue payload.
|
||
//
|
||
// Both the background poller (`server/utils/poller.js`) and the webhook
|
||
// processor (`server/routes/webhook.js`) build the `poll:sonarr-queue` and
|
||
// `poll:radarr-queue` cache entries from an array of per-instance queue
|
||
// responses. Historically the same `flatMap` block was duplicated across all
|
||
// four call sites (Sonarr + Radarr × poller + webhook) and had begun to drift.
|
||
//
|
||
// This module centralises that logic, adds defensive null-guards, and — for
|
||
// Sonarr only — annotates season-pack records (queue entries sharing a
|
||
// `downloadId`) with `isSeasonPack` and `episodeCount`. See Issue #61.
|
||
//
|
||
const { logToFile } = require('./logger');
|
||
|
||
/**
|
||
* Build the flattened, instance-tagged `records` array for the
|
||
* `poll:sonarr-queue` / `poll:radarr-queue` cache entry.
|
||
*
|
||
* @param {Array<{ instance: string, data: { records?: Array<object> } }>} queues
|
||
* Per-instance queue responses as returned by
|
||
* `arrRetrieverRegistry.getQueuesByType()` (or the equivalent batched
|
||
* retrieval in the poller).
|
||
* @param {Array<{ id: string, url: string, apiKey: string, name?: string }>} instances
|
||
* Configured instances; used to resolve `_instanceUrl` / `_instanceKey`.
|
||
* @param {'series'|'movie'} mediaKey
|
||
* Sonarr records embed a `series` object; Radarr records embed a `movie`
|
||
* object. The embedded object is annotated with `_instanceUrl` so that
|
||
* downstream link builders work.
|
||
* @returns {Array<object>} The flattened, annotated records array.
|
||
*/
|
||
function buildArrQueueCache(queues, instances, mediaKey) {
|
||
if (!Array.isArray(queues) || queues.length === 0) return [];
|
||
if (mediaKey !== 'series' && mediaKey !== 'movie') {
|
||
logToFile(`[arrQueueHelpers] Invalid mediaKey "${mediaKey}"; expected 'series' or 'movie'`);
|
||
return [];
|
||
}
|
||
const safeInstances = Array.isArray(instances) ? instances : [];
|
||
|
||
const out = [];
|
||
for (const q of queues) {
|
||
try {
|
||
if (!q || !q.data) continue;
|
||
const inst = safeInstances.find(i => i.id === q.instance);
|
||
const url = inst ? inst.url : null;
|
||
const key = inst ? inst.apiKey : null;
|
||
const records = Array.isArray(q.data.records) ? q.data.records : [];
|
||
for (const r of records) {
|
||
try {
|
||
if (!r) continue;
|
||
if (r[mediaKey]) {
|
||
r[mediaKey]._instanceUrl = url;
|
||
}
|
||
r._instanceUrl = url;
|
||
r._instanceKey = key;
|
||
out.push(r);
|
||
} catch (perRecordErr) {
|
||
logToFile(`[arrQueueHelpers] Skipping malformed ${mediaKey} record: ${perRecordErr.message}`);
|
||
}
|
||
}
|
||
} catch (perInstanceErr) {
|
||
logToFile(`[arrQueueHelpers] Skipping malformed ${mediaKey} queue payload: ${perInstanceErr.message}`);
|
||
}
|
||
}
|
||
|
||
// Sonarr-only: season pack annotation. Group by downloadId; entries that
|
||
// share a downloadId are episodes belonging to the same release (a season
|
||
// pack). Movies (mediaKey === 'movie') are single-record by nature.
|
||
if (mediaKey === 'series') {
|
||
try {
|
||
const groups = new Map();
|
||
for (const r of out) {
|
||
const dlId = r && r.downloadId;
|
||
if (!dlId) continue;
|
||
if (!groups.has(dlId)) groups.set(dlId, []);
|
||
groups.get(dlId).push(r);
|
||
}
|
||
for (const group of groups.values()) {
|
||
if (group.length > 1) {
|
||
for (const r of group) {
|
||
r.isSeasonPack = true;
|
||
r.episodeCount = group.length;
|
||
}
|
||
}
|
||
}
|
||
} catch (annotateErr) {
|
||
logToFile(`[arrQueueHelpers] Season-pack annotation failed: ${annotateErr.message}`);
|
||
}
|
||
}
|
||
|
||
return out;
|
||
}
|
||
|
||
module.exports = {
|
||
buildArrQueueCache
|
||
};
|