You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
719 lines
21 KiB
719 lines
21 KiB
import type { PlexMetadata } from '@server/api/plexapi';
|
|
import PlexAPI from '@server/api/plexapi';
|
|
import RadarrAPI from '@server/api/servarr/radarr';
|
|
import type { SonarrSeason } from '@server/api/servarr/sonarr';
|
|
import SonarrAPI from '@server/api/servarr/sonarr';
|
|
import { MediaStatus } from '@server/constants/media';
|
|
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 type { RadarrSettings, SonarrSettings } from '@server/lib/settings';
|
|
import { getSettings } from '@server/lib/settings';
|
|
import logger from '@server/logger';
|
|
|
|
class AvailabilitySync {
|
|
public running = false;
|
|
private plexClient: PlexAPI;
|
|
private plexSeasonsCache: Record<string, PlexMetadata[]> = {};
|
|
private sonarrSeasonsCache: Record<string, SonarrSeason[]> = {};
|
|
private radarrServers: RadarrSettings[];
|
|
private sonarrServers: SonarrSettings[];
|
|
|
|
async run() {
|
|
const settings = getSettings();
|
|
this.running = true;
|
|
this.plexSeasonsCache = {};
|
|
this.sonarrSeasonsCache = {};
|
|
this.radarrServers = settings.radarr.filter((server) => server.syncEnabled);
|
|
this.sonarrServers = settings.sonarr.filter((server) => server.syncEnabled);
|
|
await this.initPlexClient();
|
|
|
|
if (!this.plexClient) {
|
|
return;
|
|
}
|
|
|
|
logger.info(`Starting availability sync...`, {
|
|
label: 'AvailabilitySync',
|
|
});
|
|
const mediaRepository = getRepository(Media);
|
|
const requestRepository = getRepository(MediaRequest);
|
|
const seasonRepository = getRepository(Season);
|
|
const seasonRequestRepository = getRepository(SeasonRequest);
|
|
|
|
const pageSize = 50;
|
|
|
|
try {
|
|
for await (const media of this.loadAvailableMediaPaginated(pageSize)) {
|
|
try {
|
|
if (!this.running) {
|
|
throw new Error('Job aborted');
|
|
}
|
|
|
|
const mediaExists = await this.mediaExists(media);
|
|
|
|
//We can not delete media so if both versions do not exist, we will change both columns to unknown or null
|
|
if (!mediaExists) {
|
|
if (
|
|
media.status !== MediaStatus.UNKNOWN ||
|
|
media.status4k !== MediaStatus.UNKNOWN
|
|
) {
|
|
const request = await requestRepository.find({
|
|
relations: {
|
|
media: true,
|
|
},
|
|
where: { media: { id: media.id } },
|
|
});
|
|
|
|
logger.info(
|
|
`${
|
|
media.mediaType === 'tv' ? media.tvdbId : media.tmdbId
|
|
} does not exist in any of your media instances. We will change its status to unknown.`,
|
|
{ label: 'AvailabilitySync' }
|
|
);
|
|
|
|
await mediaRepository.update(media.id, {
|
|
status: MediaStatus.UNKNOWN,
|
|
status4k: MediaStatus.UNKNOWN,
|
|
serviceId: null,
|
|
serviceId4k: null,
|
|
externalServiceId: null,
|
|
externalServiceId4k: null,
|
|
externalServiceSlug: null,
|
|
externalServiceSlug4k: null,
|
|
ratingKey: null,
|
|
ratingKey4k: null,
|
|
});
|
|
|
|
await requestRepository.remove(request);
|
|
}
|
|
}
|
|
|
|
if (media.mediaType === 'tv') {
|
|
// ok, the show itself exists, but do all it's seasons?
|
|
const seasons = await seasonRepository.find({
|
|
where: [
|
|
{ status: MediaStatus.AVAILABLE, media: { id: media.id } },
|
|
{
|
|
status: MediaStatus.PARTIALLY_AVAILABLE,
|
|
media: { id: media.id },
|
|
},
|
|
{ status4k: MediaStatus.AVAILABLE, media: { id: media.id } },
|
|
{
|
|
status4k: MediaStatus.PARTIALLY_AVAILABLE,
|
|
media: { id: media.id },
|
|
},
|
|
],
|
|
});
|
|
|
|
let didDeleteSeasons = false;
|
|
for (const season of seasons) {
|
|
if (
|
|
!mediaExists &&
|
|
(season.status !== MediaStatus.UNKNOWN ||
|
|
season.status4k !== MediaStatus.UNKNOWN)
|
|
) {
|
|
await seasonRepository.update(
|
|
{ id: season.id },
|
|
{
|
|
status: MediaStatus.UNKNOWN,
|
|
status4k: MediaStatus.UNKNOWN,
|
|
}
|
|
);
|
|
} else {
|
|
const seasonExists = await this.seasonExists(media, season);
|
|
|
|
if (!seasonExists) {
|
|
logger.info(
|
|
`Removing season ${season.seasonNumber}, media id: ${media.tvdbId} because it does not exist in any of your media instances.`,
|
|
{ label: 'AvailabilitySync' }
|
|
);
|
|
|
|
if (
|
|
season.status !== MediaStatus.UNKNOWN ||
|
|
season.status4k !== MediaStatus.UNKNOWN
|
|
) {
|
|
await seasonRepository.update(
|
|
{ id: season.id },
|
|
{
|
|
status: MediaStatus.UNKNOWN,
|
|
status4k: MediaStatus.UNKNOWN,
|
|
}
|
|
);
|
|
}
|
|
|
|
const seasonToBeDeleted =
|
|
await seasonRequestRepository.findOne({
|
|
relations: {
|
|
request: {
|
|
media: true,
|
|
},
|
|
},
|
|
where: {
|
|
request: {
|
|
media: {
|
|
id: media.id,
|
|
},
|
|
},
|
|
seasonNumber: season.seasonNumber,
|
|
},
|
|
});
|
|
|
|
if (seasonToBeDeleted) {
|
|
await seasonRequestRepository.remove(seasonToBeDeleted);
|
|
}
|
|
|
|
didDeleteSeasons = true;
|
|
}
|
|
}
|
|
|
|
if (didDeleteSeasons) {
|
|
if (
|
|
media.status === MediaStatus.AVAILABLE ||
|
|
media.status4k === MediaStatus.AVAILABLE
|
|
) {
|
|
logger.info(
|
|
`Marking media id: ${media.tvdbId} as PARTIALLY_AVAILABLE because we deleted some of its seasons.`,
|
|
{ label: 'AvailabilitySync' }
|
|
);
|
|
|
|
if (media.status === MediaStatus.AVAILABLE) {
|
|
await mediaRepository.update(media.id, {
|
|
status: MediaStatus.PARTIALLY_AVAILABLE,
|
|
});
|
|
}
|
|
|
|
if (media.status4k === MediaStatus.AVAILABLE) {
|
|
await mediaRepository.update(media.id, {
|
|
status4k: MediaStatus.PARTIALLY_AVAILABLE,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} catch (ex) {
|
|
logger.error('Failure with media.', {
|
|
errorMessage: ex.message,
|
|
label: 'AvailabilitySync',
|
|
});
|
|
}
|
|
}
|
|
} catch (ex) {
|
|
logger.error('Failed to complete availability sync.', {
|
|
errorMessage: ex.message,
|
|
label: 'AvailabilitySync',
|
|
});
|
|
} finally {
|
|
logger.info(`Availability sync complete.`, {
|
|
label: 'AvailabilitySync',
|
|
});
|
|
this.running = false;
|
|
}
|
|
}
|
|
|
|
public cancel() {
|
|
this.running = false;
|
|
}
|
|
|
|
private async *loadAvailableMediaPaginated(pageSize: number) {
|
|
let offset = 0;
|
|
const mediaRepository = getRepository(Media);
|
|
const whereOptions = [
|
|
{ status: MediaStatus.AVAILABLE },
|
|
{ status: MediaStatus.PARTIALLY_AVAILABLE },
|
|
{ status4k: MediaStatus.AVAILABLE },
|
|
{ status4k: MediaStatus.PARTIALLY_AVAILABLE },
|
|
];
|
|
|
|
let mediaPage: Media[];
|
|
|
|
do {
|
|
yield* (mediaPage = await mediaRepository.find({
|
|
where: whereOptions,
|
|
skip: offset,
|
|
take: pageSize,
|
|
}));
|
|
offset += pageSize;
|
|
} while (mediaPage.length > 0);
|
|
}
|
|
|
|
private async mediaUpdater(media: Media, is4k: boolean): Promise<void> {
|
|
const mediaRepository = getRepository(Media);
|
|
const requestRepository = getRepository(MediaRequest);
|
|
|
|
const isTVType = media.mediaType === 'tv';
|
|
|
|
const request = await requestRepository.findOne({
|
|
relations: {
|
|
media: true,
|
|
},
|
|
where: { media: { id: media.id }, is4k: is4k ? true : false },
|
|
});
|
|
|
|
logger.info(
|
|
`${media.tmdbId} does not exist in your ${is4k ? '4k' : 'non-4k'} ${
|
|
isTVType ? 'sonarr' : 'radarr'
|
|
} and plex instance. We will change its status to unknown.`,
|
|
{ label: 'AvailabilitySync' }
|
|
);
|
|
|
|
await mediaRepository.update(
|
|
media.id,
|
|
is4k
|
|
? {
|
|
status4k: MediaStatus.UNKNOWN,
|
|
serviceId4k: null,
|
|
externalServiceId4k: null,
|
|
externalServiceSlug4k: null,
|
|
ratingKey4k: null,
|
|
}
|
|
: {
|
|
status: MediaStatus.UNKNOWN,
|
|
serviceId: null,
|
|
externalServiceId: null,
|
|
externalServiceSlug: null,
|
|
ratingKey: null,
|
|
}
|
|
);
|
|
|
|
if (isTVType) {
|
|
const seasonRepository = getRepository(Season);
|
|
|
|
await seasonRepository?.update(
|
|
{ media: { id: media.id } },
|
|
is4k
|
|
? { status4k: MediaStatus.UNKNOWN }
|
|
: { status: MediaStatus.UNKNOWN }
|
|
);
|
|
}
|
|
|
|
await requestRepository.delete({ id: request?.id });
|
|
}
|
|
|
|
private async mediaExistsInRadarr(
|
|
media: Media,
|
|
existsInPlex: boolean,
|
|
existsInPlex4k: boolean
|
|
): Promise<boolean> {
|
|
let existsInRadarr = true;
|
|
let existsInRadarr4k = true;
|
|
|
|
for (const server of this.radarrServers) {
|
|
const api = new RadarrAPI({
|
|
apiKey: server.apiKey,
|
|
url: RadarrAPI.buildUrl(server, '/api/v3'),
|
|
});
|
|
const meta = await api.getMovieByTmdbId(media.tmdbId);
|
|
|
|
//check if both exist or if a single non-4k or 4k exists
|
|
//if both do not exist we will return false
|
|
if (!server.is4k && !meta.id) {
|
|
existsInRadarr = false;
|
|
}
|
|
|
|
if (server.is4k && !meta.id) {
|
|
existsInRadarr4k = false;
|
|
}
|
|
}
|
|
|
|
if (existsInRadarr && existsInRadarr4k) {
|
|
return true;
|
|
}
|
|
|
|
if (!existsInRadarr && existsInPlex) {
|
|
return true;
|
|
}
|
|
|
|
if (!existsInRadarr4k && existsInPlex4k) {
|
|
return true;
|
|
}
|
|
|
|
//if only a single non-4k or 4k exists, then change entity columns accordingly
|
|
//related media request will then be deleted
|
|
if (!existsInRadarr && existsInRadarr4k && !existsInPlex) {
|
|
if (media.status !== MediaStatus.UNKNOWN) {
|
|
this.mediaUpdater(media, false);
|
|
}
|
|
}
|
|
|
|
if (existsInRadarr && !existsInRadarr4k && !existsInPlex4k) {
|
|
if (media.status4k !== MediaStatus.UNKNOWN) {
|
|
this.mediaUpdater(media, true);
|
|
}
|
|
}
|
|
|
|
if (existsInRadarr || existsInRadarr4k) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private async mediaExistsInSonarr(
|
|
media: Media,
|
|
existsInPlex: boolean,
|
|
existsInPlex4k: boolean
|
|
): Promise<boolean> {
|
|
if (!media.tvdbId) {
|
|
return false;
|
|
}
|
|
|
|
let existsInSonarr = true;
|
|
let existsInSonarr4k = true;
|
|
|
|
for (const server of this.sonarrServers) {
|
|
const api = new SonarrAPI({
|
|
apiKey: server.apiKey,
|
|
url: SonarrAPI.buildUrl(server, '/api/v3'),
|
|
});
|
|
|
|
const meta = await api.getSeriesByTvdbId(media.tvdbId);
|
|
|
|
this.sonarrSeasonsCache[`${server.id}-${media.tvdbId}`] = meta.seasons;
|
|
|
|
//check if both exist or if a single non-4k or 4k exists
|
|
//if both do not exist we will return false
|
|
if (!server.is4k && !meta.id) {
|
|
existsInSonarr = false;
|
|
}
|
|
|
|
if (server.is4k && !meta.id) {
|
|
existsInSonarr4k = false;
|
|
}
|
|
}
|
|
|
|
if (existsInSonarr && existsInSonarr4k) {
|
|
return true;
|
|
}
|
|
|
|
if (!existsInSonarr && existsInPlex) {
|
|
return true;
|
|
}
|
|
|
|
if (!existsInSonarr4k && existsInPlex4k) {
|
|
return true;
|
|
}
|
|
|
|
//if only a single non-4k or 4k exists, then change entity columns accordingly
|
|
//related media request will then be deleted
|
|
if (!existsInSonarr && existsInSonarr4k && !existsInPlex) {
|
|
if (media.status !== MediaStatus.UNKNOWN) {
|
|
this.mediaUpdater(media, false);
|
|
}
|
|
}
|
|
|
|
if (existsInSonarr && !existsInSonarr4k && !existsInPlex4k) {
|
|
if (media.status4k !== MediaStatus.UNKNOWN) {
|
|
this.mediaUpdater(media, true);
|
|
}
|
|
}
|
|
|
|
if (existsInSonarr || existsInSonarr4k) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private async seasonExistsInSonarr(
|
|
media: Media,
|
|
season: Season,
|
|
seasonExistsInPlex: boolean,
|
|
seasonExistsInPlex4k: boolean
|
|
): Promise<boolean> {
|
|
if (!media.tvdbId) {
|
|
return false;
|
|
}
|
|
|
|
let seasonExistsInSonarr = true;
|
|
let seasonExistsInSonarr4k = true;
|
|
|
|
const mediaRepository = getRepository(Media);
|
|
const seasonRepository = getRepository(Season);
|
|
const seasonRequestRepository = getRepository(SeasonRequest);
|
|
|
|
for (const server of this.sonarrServers) {
|
|
const api = new SonarrAPI({
|
|
apiKey: server.apiKey,
|
|
url: SonarrAPI.buildUrl(server, '/api/v3'),
|
|
});
|
|
|
|
const seasons =
|
|
this.sonarrSeasonsCache[`${server.id}-${media.tvdbId}`] ??
|
|
(await api.getSeriesByTvdbId(media.tvdbId)).seasons;
|
|
this.sonarrSeasonsCache[`${server.id}-${media.tvdbId}`] = seasons;
|
|
|
|
const hasMonitoredSeason = seasons.find(
|
|
({ monitored, seasonNumber }) =>
|
|
monitored && season.seasonNumber === seasonNumber
|
|
);
|
|
|
|
if (!server.is4k && !hasMonitoredSeason) {
|
|
seasonExistsInSonarr = false;
|
|
}
|
|
|
|
if (server.is4k && !hasMonitoredSeason) {
|
|
seasonExistsInSonarr4k = false;
|
|
}
|
|
}
|
|
|
|
if (seasonExistsInSonarr && seasonExistsInSonarr4k) {
|
|
return true;
|
|
}
|
|
|
|
if (!seasonExistsInSonarr && seasonExistsInPlex) {
|
|
return true;
|
|
}
|
|
|
|
if (!seasonExistsInSonarr4k && seasonExistsInPlex4k) {
|
|
return true;
|
|
}
|
|
|
|
const seasonToBeDeleted = await seasonRequestRepository.findOne({
|
|
relations: {
|
|
request: {
|
|
media: true,
|
|
},
|
|
},
|
|
where: {
|
|
request: {
|
|
is4k: seasonExistsInSonarr ? true : false,
|
|
media: {
|
|
id: media.id,
|
|
},
|
|
},
|
|
seasonNumber: season.seasonNumber,
|
|
},
|
|
});
|
|
|
|
//if season does not exist, we will change status to unknown and delete related season request
|
|
//if parent media request is empty(all related seasons have been removed), parent is automatically deleted
|
|
if (
|
|
!seasonExistsInSonarr &&
|
|
seasonExistsInSonarr4k &&
|
|
!seasonExistsInPlex
|
|
) {
|
|
if (season.status !== MediaStatus.UNKNOWN) {
|
|
logger.info(
|
|
`${media.tvdbId}, season: ${season.seasonNumber} does not exist in your non-4k sonarr and plex instance. We will change its status to unknown.`,
|
|
{ label: 'AvailabilitySync' }
|
|
);
|
|
await seasonRepository.update(season.id, {
|
|
status: MediaStatus.UNKNOWN,
|
|
});
|
|
|
|
if (seasonToBeDeleted) {
|
|
await seasonRequestRepository.remove(seasonToBeDeleted);
|
|
}
|
|
|
|
if (media.status === MediaStatus.AVAILABLE) {
|
|
logger.info(
|
|
`Marking media id: ${media.tvdbId} as PARTIALLY_AVAILABLE because we deleted one of its seasons.`,
|
|
{ label: 'AvailabilitySync' }
|
|
);
|
|
await mediaRepository.update(media.id, {
|
|
status: MediaStatus.PARTIALLY_AVAILABLE,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
if (
|
|
seasonExistsInSonarr &&
|
|
!seasonExistsInSonarr4k &&
|
|
!seasonExistsInPlex4k
|
|
) {
|
|
if (season.status4k !== MediaStatus.UNKNOWN) {
|
|
logger.info(
|
|
`${media.tvdbId}, season: ${season.seasonNumber} does not exist in your 4k sonarr and plex instance. We will change its status to unknown.`,
|
|
{ label: 'AvailabilitySync' }
|
|
);
|
|
await seasonRepository.update(season.id, {
|
|
status4k: MediaStatus.UNKNOWN,
|
|
});
|
|
|
|
if (seasonToBeDeleted) {
|
|
await seasonRequestRepository.remove(seasonToBeDeleted);
|
|
}
|
|
|
|
if (media.status4k === MediaStatus.AVAILABLE) {
|
|
logger.info(
|
|
`Marking media id: ${media.tvdbId} as PARTIALLY_AVAILABLE because we deleted one of its seasons.`,
|
|
{ label: 'AvailabilitySync' }
|
|
);
|
|
await mediaRepository.update(media.id, {
|
|
status4k: MediaStatus.PARTIALLY_AVAILABLE,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
if (seasonExistsInSonarr || seasonExistsInSonarr4k) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private async mediaExists(media: Media): Promise<boolean> {
|
|
const ratingKey = media.ratingKey;
|
|
const ratingKey4k = media.ratingKey4k;
|
|
|
|
let existsInPlex = false;
|
|
let existsInPlex4k = false;
|
|
|
|
//check each plex instance to see if media exists
|
|
try {
|
|
if (ratingKey) {
|
|
const meta = await this.plexClient?.getMetadata(ratingKey);
|
|
if (meta) {
|
|
existsInPlex = true;
|
|
}
|
|
}
|
|
if (ratingKey4k) {
|
|
const meta4k = await this.plexClient?.getMetadata(ratingKey4k);
|
|
if (meta4k) {
|
|
existsInPlex4k = true;
|
|
}
|
|
}
|
|
} catch (ex) {
|
|
// TODO: oof, not the nicest way of handling this, but plex-api does not leave us with any other options...
|
|
if (!ex.message.includes('response code: 404')) {
|
|
throw ex;
|
|
}
|
|
}
|
|
//base case for if both media versions exist in plex
|
|
if (existsInPlex && existsInPlex4k) {
|
|
return true;
|
|
}
|
|
|
|
//we then check radarr or sonarr has that specific media. If not, then we will move to delete
|
|
//if a non-4k or 4k version exists in at least one of the instances, we will only update that specific version
|
|
if (media.mediaType === 'movie') {
|
|
const existsInRadarr = await this.mediaExistsInRadarr(
|
|
media,
|
|
existsInPlex,
|
|
existsInPlex4k
|
|
);
|
|
|
|
//if true, media exists in at least one radarr or plex instance.
|
|
if (existsInRadarr) {
|
|
logger.warn(
|
|
`${media.tmdbId} exists in at least one radarr or plex instance. Media will be updated if set to available.`,
|
|
{
|
|
label: 'AvailabilitySync',
|
|
}
|
|
);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (media.mediaType === 'tv') {
|
|
const existsInSonarr = await this.mediaExistsInSonarr(
|
|
media,
|
|
existsInPlex,
|
|
existsInPlex4k
|
|
);
|
|
|
|
//if true, media exists in at least one sonarr or plex instance.
|
|
if (existsInSonarr) {
|
|
logger.warn(
|
|
`${media.tvdbId} exists in at least one sonarr or plex instance. Media will be updated if set to available.`,
|
|
{
|
|
label: 'AvailabilitySync',
|
|
}
|
|
);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private async seasonExists(media: Media, season: Season) {
|
|
const ratingKey = media.ratingKey;
|
|
const ratingKey4k = media.ratingKey4k;
|
|
|
|
let seasonExistsInPlex = false;
|
|
let seasonExistsInPlex4k = false;
|
|
|
|
if (ratingKey) {
|
|
const children =
|
|
this.plexSeasonsCache[ratingKey] ??
|
|
(await this.plexClient?.getChildrenMetadata(ratingKey)) ??
|
|
[];
|
|
this.plexSeasonsCache[ratingKey] = children;
|
|
const seasonMeta = children?.find(
|
|
(child) => child.index === season.seasonNumber
|
|
);
|
|
|
|
if (seasonMeta) {
|
|
seasonExistsInPlex = true;
|
|
}
|
|
}
|
|
|
|
if (ratingKey4k) {
|
|
const children4k =
|
|
this.plexSeasonsCache[ratingKey4k] ??
|
|
(await this.plexClient?.getChildrenMetadata(ratingKey4k)) ??
|
|
[];
|
|
this.plexSeasonsCache[ratingKey4k] = children4k;
|
|
const seasonMeta4k = children4k?.find(
|
|
(child) => child.index === season.seasonNumber
|
|
);
|
|
|
|
if (seasonMeta4k) {
|
|
seasonExistsInPlex4k = true;
|
|
}
|
|
}
|
|
|
|
//base case for if both season versions exist in plex
|
|
if (seasonExistsInPlex && seasonExistsInPlex4k) {
|
|
return true;
|
|
}
|
|
|
|
const existsInSonarr = await this.seasonExistsInSonarr(
|
|
media,
|
|
season,
|
|
seasonExistsInPlex,
|
|
seasonExistsInPlex4k
|
|
);
|
|
|
|
if (existsInSonarr) {
|
|
logger.warn(
|
|
`${media.tvdbId}, season: ${season.seasonNumber} exists in at least one sonarr or plex instance. Media will be updated if set to available.`,
|
|
{
|
|
label: 'AvailabilitySync',
|
|
}
|
|
);
|
|
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private async initPlexClient() {
|
|
const userRepository = getRepository(User);
|
|
const admin = await userRepository.findOne({
|
|
select: { id: true, plexToken: true },
|
|
where: { id: 1 },
|
|
});
|
|
|
|
if (!admin) {
|
|
logger.warning('No admin configured. Availability sync skipped.');
|
|
return;
|
|
}
|
|
|
|
this.plexClient = new PlexAPI({ plexToken: admin.plexToken });
|
|
}
|
|
}
|
|
|
|
const availabilitySync = new AvailabilitySync();
|
|
export default availabilitySync;
|