Homelabtoolkit v2
This commit is contained in:
@@ -0,0 +1,695 @@
|
||||
import { error, json } from '@sveltejs/kit';
|
||||
import {
|
||||
RECOMMENDATION_PROFILES,
|
||||
rankRecommendationResults,
|
||||
normalizeLookupItem
|
||||
} from '../../../lib/collection-tools.js';
|
||||
import { fetchEmby, fetchEmbyJson, normalizeEmbyGuid } from '../../../lib/server/emby-api.js';
|
||||
import {
|
||||
fetchTmdbCredits,
|
||||
fetchTmdbDetails,
|
||||
fetchTmdbDiscover,
|
||||
fetchTmdbGenres,
|
||||
fetchTmdbKeywords,
|
||||
fetchTmdbRecommendations,
|
||||
fetchTmdbSimilar,
|
||||
searchTmdbByTitle
|
||||
} from '../../../lib/server/tmdb-api.js';
|
||||
|
||||
const EMBY_PAGE_SIZE = 200;
|
||||
|
||||
function normalizeTitle(value) {
|
||||
return String(value || '')
|
||||
.toLowerCase()
|
||||
.replace(/[^a-z0-9]+/g, '');
|
||||
}
|
||||
|
||||
function normalizeYear(value) {
|
||||
const year = Number(value || 0);
|
||||
return Number.isFinite(year) && year > 0 ? year : null;
|
||||
}
|
||||
|
||||
function titleYearKey(name, year) {
|
||||
return `${normalizeTitle(name)}::${normalizeYear(year) || ''}`;
|
||||
}
|
||||
|
||||
function normalizeCollectionName(name) {
|
||||
return String(name || '')
|
||||
.toLowerCase()
|
||||
.replace(/['’]/g, '')
|
||||
.replace(/[^a-z0-9]+/g, '');
|
||||
}
|
||||
|
||||
function getSeedTmdbId(item) {
|
||||
const providerIds = item?.providerIds || {};
|
||||
return String(providerIds.Tmdb || providerIds.TMDB || providerIds.tmdb || '').trim();
|
||||
}
|
||||
|
||||
function getTmdbMediaType(item) {
|
||||
return item?.type === 'Series' ? 'tv' : 'movie';
|
||||
}
|
||||
|
||||
function summarizeItems(items, limit = 5) {
|
||||
return (items || []).slice(0, limit).map((item) => ({
|
||||
name: item?.name || item?.title || item?.Name || '',
|
||||
year: item?.year || item?.ProductionYear || null,
|
||||
id: item?.id || item?.Id || '',
|
||||
type: item?.type || item?.Type || ''
|
||||
}));
|
||||
}
|
||||
|
||||
function filterEnglishCandidates(items) {
|
||||
return (items || []).filter((item) => !item?.originalLanguage || item.originalLanguage === 'en');
|
||||
}
|
||||
|
||||
async function fetchAllUserItems(userId, params) {
|
||||
const allItems = [];
|
||||
let startIndex = 0;
|
||||
|
||||
while (true) {
|
||||
const payload = await fetchEmbyJson(`/Users/${encodeURIComponent(userId)}/Items`, {
|
||||
params: {
|
||||
Recursive: true,
|
||||
GroupItemsIntoCollections: false,
|
||||
Limit: EMBY_PAGE_SIZE,
|
||||
StartIndex: startIndex,
|
||||
...params
|
||||
}
|
||||
});
|
||||
|
||||
const pageItems = (payload.Items || payload || []).map(normalizeLookupItem);
|
||||
allItems.push(...pageItems);
|
||||
|
||||
const total = Number(payload.TotalRecordCount || 0);
|
||||
if (!pageItems.length) break;
|
||||
if (total > 0 && allItems.length >= total) break;
|
||||
if (pageItems.length < EMBY_PAGE_SIZE) break;
|
||||
|
||||
startIndex += pageItems.length;
|
||||
}
|
||||
|
||||
return allItems;
|
||||
}
|
||||
|
||||
async function fetchAllLibraryItems(userId) {
|
||||
return fetchAllUserItems(userId, {
|
||||
IncludeItemTypes: 'Movie,Series',
|
||||
Fields: 'Overview,Genres,CommunityRating,ProductionYear,ProviderIds'
|
||||
});
|
||||
}
|
||||
|
||||
async function fetchAllPlayedItems(userId) {
|
||||
return fetchAllUserItems(userId, {
|
||||
Filters: 'IsPlayed',
|
||||
IncludeItemTypes: 'Movie,Series',
|
||||
SortBy: 'DatePlayed',
|
||||
SortOrder: 'Descending',
|
||||
Fields: 'Overview,Genres,CommunityRating,ProductionYear,ProviderIds,UserData'
|
||||
});
|
||||
}
|
||||
|
||||
function uniqueById(items) {
|
||||
const seen = new Set();
|
||||
const unique = [];
|
||||
for (const item of items || []) {
|
||||
if (!item?.id || seen.has(item.id)) continue;
|
||||
seen.add(item.id);
|
||||
unique.push(item);
|
||||
}
|
||||
return unique;
|
||||
}
|
||||
|
||||
function buildLibraryIndex(items) {
|
||||
const byId = new Map();
|
||||
const byTmdbId = new Map();
|
||||
const byTitleYear = new Map();
|
||||
const byTitle = new Map();
|
||||
|
||||
for (const item of items || []) {
|
||||
if (!item?.id) continue;
|
||||
byId.set(item.id, item);
|
||||
|
||||
const tmdbId = getSeedTmdbId(item);
|
||||
if (tmdbId && !byTmdbId.has(tmdbId)) {
|
||||
byTmdbId.set(tmdbId, item);
|
||||
}
|
||||
|
||||
const titleKey = titleYearKey(item.name, item.year);
|
||||
if (normalizeTitle(item.name) && !byTitleYear.has(titleKey)) {
|
||||
byTitleYear.set(titleKey, item);
|
||||
}
|
||||
|
||||
const normalizedName = normalizeTitle(item.name);
|
||||
if (normalizedName && !byTitle.has(normalizedName)) {
|
||||
byTitle.set(normalizedName, item);
|
||||
}
|
||||
}
|
||||
|
||||
return { byId, byTmdbId, byTitleYear, byTitle };
|
||||
}
|
||||
|
||||
async function fetchSeedItems(userId, ids, libraryIndex) {
|
||||
const fromLibrary = ids
|
||||
.map((id) => libraryIndex.byId.get(String(id)))
|
||||
.filter(Boolean);
|
||||
|
||||
if (fromLibrary.length === ids.length) {
|
||||
return fromLibrary;
|
||||
}
|
||||
|
||||
const payload = await fetchEmbyJson(`/Users/${encodeURIComponent(userId)}/Items`, {
|
||||
params: {
|
||||
Ids: ids.join(','),
|
||||
Limit: ids.length,
|
||||
Fields: 'Overview,Genres,CommunityRating,ProductionYear,ProviderIds',
|
||||
GroupItemsIntoCollections: false
|
||||
}
|
||||
});
|
||||
|
||||
return uniqueById((payload.Items || payload || []).map(normalizeLookupItem));
|
||||
}
|
||||
|
||||
async function findExistingCollection(userId, name) {
|
||||
const trimmedName = String(name || '').trim();
|
||||
if (!userId || !trimmedName) return null;
|
||||
|
||||
const payload = await fetchEmbyJson(`/Users/${encodeURIComponent(userId)}/Items`, {
|
||||
params: {
|
||||
Recursive: true,
|
||||
SearchTerm: trimmedName,
|
||||
Limit: 20,
|
||||
SortBy: 'SortName',
|
||||
SortOrder: 'Ascending',
|
||||
Fields: 'Overview',
|
||||
IncludeItemTypes: 'BoxSet',
|
||||
GroupItemsIntoCollections: false
|
||||
}
|
||||
});
|
||||
|
||||
const normalizedTarget = normalizeCollectionName(trimmedName);
|
||||
const exact = (payload.Items || payload || [])
|
||||
.map(normalizeLookupItem)
|
||||
.find((item) => item.type === 'BoxSet' && normalizeCollectionName(item.name) === normalizedTarget);
|
||||
|
||||
return exact || null;
|
||||
}
|
||||
|
||||
async function resolveTmdbMatch(item) {
|
||||
const directTmdbId = getSeedTmdbId(item);
|
||||
if (directTmdbId) {
|
||||
return {
|
||||
tmdbId: Number(directTmdbId),
|
||||
mediaType: getTmdbMediaType(item)
|
||||
};
|
||||
}
|
||||
|
||||
const matches = await searchTmdbByTitle({
|
||||
mediaType: getTmdbMediaType(item),
|
||||
name: item.name,
|
||||
year: item.year
|
||||
});
|
||||
const best = matches[0];
|
||||
if (!best?.tmdbId) return null;
|
||||
|
||||
return {
|
||||
tmdbId: best.tmdbId,
|
||||
mediaType: best.mediaType
|
||||
};
|
||||
}
|
||||
|
||||
function resolveLocalCandidate(index, candidate) {
|
||||
const tmdbId = String(candidate?.tmdbId || '').trim();
|
||||
if (tmdbId && index.byTmdbId.has(tmdbId)) {
|
||||
return index.byTmdbId.get(tmdbId);
|
||||
}
|
||||
|
||||
const exactTitleYear = index.byTitleYear.get(titleYearKey(candidate?.name, candidate?.year));
|
||||
if (exactTitleYear) {
|
||||
return exactTitleYear;
|
||||
}
|
||||
|
||||
return index.byTitle.get(normalizeTitle(candidate?.name)) || null;
|
||||
}
|
||||
|
||||
function addWeight(map, key, amount = 1) {
|
||||
if (key === null || key === undefined || key === '') return;
|
||||
map.set(key, (map.get(key) || 0) + amount);
|
||||
}
|
||||
|
||||
function sortWeightedEntries(map, limit) {
|
||||
return [...map.entries()]
|
||||
.sort((a, b) => b[1] - a[1])
|
||||
.slice(0, limit);
|
||||
}
|
||||
|
||||
function getGenreLookup(genres) {
|
||||
return new Map((genres || []).map((genre) => [normalizeTitle(genre.name), Number(genre.id)]));
|
||||
}
|
||||
|
||||
function resolveGenreIdsFromLocalItems(items, genreLookup, weight, targetMap) {
|
||||
for (const item of items || []) {
|
||||
for (const genreName of item.genres || []) {
|
||||
const id = genreLookup.get(normalizeTitle(genreName));
|
||||
if (id) addWeight(targetMap, id, weight);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function normalizeKeywordIds(keywords) {
|
||||
return (keywords || []).map((keyword) => Number(keyword?.id || 0)).filter(Boolean);
|
||||
}
|
||||
|
||||
function extractPeopleIds(credits, mediaType) {
|
||||
const ids = new Set();
|
||||
|
||||
for (const person of (credits?.cast || []).slice(0, 5)) {
|
||||
if (person?.id) ids.add(Number(person.id));
|
||||
}
|
||||
|
||||
if (mediaType === 'movie') {
|
||||
for (const crew of credits?.crew || []) {
|
||||
if (!crew?.id) continue;
|
||||
if (crew.job === 'Director' || crew.job === 'Writer' || crew.job === 'Screenplay') {
|
||||
ids.add(Number(crew.id));
|
||||
}
|
||||
if (ids.size >= 8) break;
|
||||
}
|
||||
}
|
||||
|
||||
return [...ids];
|
||||
}
|
||||
|
||||
function buildDiscoverQueries({ mediaType, genreIds, keywordIds, peopleIds }) {
|
||||
const base = {
|
||||
page: 1,
|
||||
sort_by: 'popularity.desc',
|
||||
'vote_count.gte': mediaType === 'tv' ? 10 : 25,
|
||||
with_original_language: 'en'
|
||||
};
|
||||
const queries = [];
|
||||
|
||||
if (genreIds.length) {
|
||||
queries.push({
|
||||
label: `${mediaType}-genres`,
|
||||
params: {
|
||||
...base,
|
||||
with_genres: genreIds.slice(0, 4).join('|')
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if (keywordIds.length) {
|
||||
queries.push({
|
||||
label: `${mediaType}-keywords`,
|
||||
params: {
|
||||
...base,
|
||||
with_keywords: keywordIds.slice(0, 6).join('|')
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if (genreIds.length && keywordIds.length) {
|
||||
queries.push({
|
||||
label: `${mediaType}-genres-keywords`,
|
||||
params: {
|
||||
...base,
|
||||
with_genres: genreIds.slice(0, 3).join('|'),
|
||||
with_keywords: keywordIds.slice(0, 4).join('|')
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
if (mediaType === 'movie' && peopleIds.length) {
|
||||
queries.push({
|
||||
label: 'movie-people',
|
||||
params: {
|
||||
...base,
|
||||
with_people: peopleIds.slice(0, 5).join('|')
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
return queries;
|
||||
}
|
||||
|
||||
function inspectCandidateSets(seedIds, resultSets) {
|
||||
const excluded = new Set((seedIds || []).map((id) => String(id)));
|
||||
const uniqueIncluded = new Map();
|
||||
const uniqueExcluded = new Map();
|
||||
|
||||
for (const resultSet of resultSets || []) {
|
||||
const items = Array.isArray(resultSet) ? resultSet : (Array.isArray(resultSet?.items) ? resultSet.items : []);
|
||||
for (const item of items) {
|
||||
const normalized = normalizeLookupItem(item);
|
||||
if (!normalized.id) continue;
|
||||
if (excluded.has(normalized.id)) {
|
||||
if (!uniqueExcluded.has(normalized.id)) uniqueExcluded.set(normalized.id, normalized);
|
||||
continue;
|
||||
}
|
||||
if (!uniqueIncluded.has(normalized.id)) uniqueIncluded.set(normalized.id, normalized);
|
||||
}
|
||||
}
|
||||
|
||||
return {
|
||||
uniqueCandidateCount: uniqueIncluded.size,
|
||||
excludedSeedCandidateCount: uniqueExcluded.size,
|
||||
sampleExcludedSeedCandidates: summarizeItems([...uniqueExcluded.values()])
|
||||
};
|
||||
}
|
||||
|
||||
async function buildSeedContext(seed, libraryIndex) {
|
||||
const diagnostic = {
|
||||
seedId: seed.id,
|
||||
seedName: seed.name,
|
||||
seedType: seed.type,
|
||||
seedYear: seed.year,
|
||||
providerTmdbId: getSeedTmdbId(seed) || null,
|
||||
tmdbMatch: null,
|
||||
similarCount: 0,
|
||||
recommendationCount: 0,
|
||||
localSimilarCount: 0,
|
||||
localRecommendationCount: 0,
|
||||
error: null
|
||||
};
|
||||
|
||||
try {
|
||||
const tmdbMatch = await resolveTmdbMatch(seed);
|
||||
if (!tmdbMatch?.tmdbId) {
|
||||
diagnostic.error = 'No TMDB match resolved for seed';
|
||||
return { seed, diagnostic, resultSets: [], details: null, keywords: [], peopleIds: [] };
|
||||
}
|
||||
|
||||
diagnostic.tmdbMatch = tmdbMatch;
|
||||
|
||||
const [details, keywords, credits, similar, recommendations] = await Promise.all([
|
||||
fetchTmdbDetails(tmdbMatch),
|
||||
fetchTmdbKeywords(tmdbMatch),
|
||||
fetchTmdbCredits(tmdbMatch),
|
||||
fetchTmdbSimilar({ ...tmdbMatch, page: 1 }),
|
||||
fetchTmdbRecommendations({ ...tmdbMatch, page: 1 })
|
||||
]);
|
||||
|
||||
const englishSimilar = filterEnglishCandidates(similar);
|
||||
const englishRecommendations = filterEnglishCandidates(recommendations);
|
||||
const localSimilar = uniqueById(englishSimilar.map((candidate) => resolveLocalCandidate(libraryIndex, candidate)).filter(Boolean));
|
||||
const localRecommendations = uniqueById(
|
||||
englishRecommendations.map((candidate) => resolveLocalCandidate(libraryIndex, candidate)).filter(Boolean)
|
||||
);
|
||||
|
||||
diagnostic.similarCount = englishSimilar.length;
|
||||
diagnostic.recommendationCount = englishRecommendations.length;
|
||||
diagnostic.localSimilarCount = localSimilar.length;
|
||||
diagnostic.localRecommendationCount = localRecommendations.length;
|
||||
|
||||
return {
|
||||
seed,
|
||||
details,
|
||||
keywords,
|
||||
peopleIds: extractPeopleIds(credits, tmdbMatch.mediaType),
|
||||
diagnostic,
|
||||
resultSets: [
|
||||
{ items: localSimilar, sourceWeight: 5, label: 'tmdb-similar' },
|
||||
{ items: localRecommendations, sourceWeight: 6, label: 'tmdb-recommendations' }
|
||||
]
|
||||
};
|
||||
} catch (err) {
|
||||
diagnostic.error = err.message;
|
||||
return { seed, diagnostic, resultSets: [], details: null, keywords: [], peopleIds: [] };
|
||||
}
|
||||
}
|
||||
|
||||
async function buildPreview(userId, seedIds, limit, profile) {
|
||||
const normalizedSeedIds = [...new Set(seedIds.map((id) => String(id).trim()).filter(Boolean))];
|
||||
const libraryItems = uniqueById(await fetchAllLibraryItems(userId));
|
||||
const playedItems = uniqueById(await fetchAllPlayedItems(userId));
|
||||
const excludedIds = [...new Set([...normalizedSeedIds, ...playedItems.map((item) => item.id).filter(Boolean)])];
|
||||
const libraryIndex = buildLibraryIndex(libraryItems);
|
||||
const seeds = await fetchSeedItems(userId, normalizedSeedIds, libraryIndex);
|
||||
const allowedTypes = [...new Set(seeds.map((item) => item.type).filter(Boolean))];
|
||||
const includeMovies = allowedTypes.includes('Movie');
|
||||
const includeSeries = allowedTypes.includes('Series');
|
||||
|
||||
if (!seeds.length) {
|
||||
return {
|
||||
seeds: [],
|
||||
recommendations: [],
|
||||
diagnostics: {
|
||||
libraryItemCount: libraryItems.length,
|
||||
watchedItemCount: playedItems.length,
|
||||
seedCount: 0,
|
||||
embyCandidates: 0,
|
||||
tmdbEnabled: true,
|
||||
tmdbCandidates: 0,
|
||||
tmdbResolved: 0,
|
||||
uniqueCandidateCount: 0,
|
||||
excludedSeedCandidateCount: 0,
|
||||
sampleExcludedSeedCandidates: [],
|
||||
perSeed: [],
|
||||
discoverQueries: []
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
const seedContexts = await Promise.all(seeds.map((seed) => buildSeedContext(seed, libraryIndex)));
|
||||
const movieGenres = await fetchTmdbGenres('movie');
|
||||
const tvGenres = await fetchTmdbGenres('tv');
|
||||
const movieGenreLookup = getGenreLookup(movieGenres);
|
||||
const tvGenreLookup = getGenreLookup(tvGenres);
|
||||
|
||||
const movieGenreWeights = new Map();
|
||||
const tvGenreWeights = new Map();
|
||||
const movieKeywordWeights = new Map();
|
||||
const tvKeywordWeights = new Map();
|
||||
const moviePeopleWeights = new Map();
|
||||
|
||||
for (const context of seedContexts) {
|
||||
const mediaType = getTmdbMediaType(context.seed);
|
||||
const genreTarget = mediaType === 'tv' ? tvGenreWeights : movieGenreWeights;
|
||||
const keywordTarget = mediaType === 'tv' ? tvKeywordWeights : movieKeywordWeights;
|
||||
|
||||
for (const genre of context.details?.genres || []) {
|
||||
addWeight(genreTarget, Number(genre.id), 5);
|
||||
}
|
||||
|
||||
for (const keywordId of normalizeKeywordIds(context.keywords)) {
|
||||
addWeight(keywordTarget, keywordId, 4);
|
||||
}
|
||||
|
||||
if (mediaType === 'movie') {
|
||||
for (const personId of context.peopleIds || []) {
|
||||
addWeight(moviePeopleWeights, personId, 3);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
resolveGenreIdsFromLocalItems(seeds.filter((item) => getTmdbMediaType(item) === 'movie'), movieGenreLookup, 3, movieGenreWeights);
|
||||
resolveGenreIdsFromLocalItems(seeds.filter((item) => getTmdbMediaType(item) === 'tv'), tvGenreLookup, 3, tvGenreWeights);
|
||||
resolveGenreIdsFromLocalItems(playedItems.filter((item) => getTmdbMediaType(item) === 'movie'), movieGenreLookup, 1, movieGenreWeights);
|
||||
resolveGenreIdsFromLocalItems(playedItems.filter((item) => getTmdbMediaType(item) === 'tv'), tvGenreLookup, 1, tvGenreWeights);
|
||||
|
||||
const discoverQueries = [
|
||||
...(includeMovies
|
||||
? buildDiscoverQueries({
|
||||
mediaType: 'movie',
|
||||
genreIds: sortWeightedEntries(movieGenreWeights, 6).map(([id]) => id),
|
||||
keywordIds: sortWeightedEntries(movieKeywordWeights, 8).map(([id]) => id),
|
||||
peopleIds: sortWeightedEntries(moviePeopleWeights, 6).map(([id]) => id)
|
||||
})
|
||||
: []),
|
||||
...(includeSeries
|
||||
? buildDiscoverQueries({
|
||||
mediaType: 'tv',
|
||||
genreIds: sortWeightedEntries(tvGenreWeights, 6).map(([id]) => id),
|
||||
keywordIds: sortWeightedEntries(tvKeywordWeights, 8).map(([id]) => id),
|
||||
peopleIds: []
|
||||
})
|
||||
: [])
|
||||
];
|
||||
|
||||
const queryResults = await Promise.all(
|
||||
discoverQueries.map(async (query) => {
|
||||
try {
|
||||
const tmdbResults = filterEnglishCandidates(await fetchTmdbDiscover({
|
||||
mediaType: query.label.startsWith('tv') ? 'tv' : 'movie',
|
||||
params: query.params
|
||||
}));
|
||||
const localMatches = uniqueById(
|
||||
tmdbResults.map((candidate) => resolveLocalCandidate(libraryIndex, candidate)).filter(Boolean)
|
||||
);
|
||||
|
||||
return {
|
||||
label: query.label,
|
||||
params: query.params,
|
||||
tmdbCount: tmdbResults.length,
|
||||
localCount: localMatches.length,
|
||||
localMatches,
|
||||
sourceWeight: 1
|
||||
};
|
||||
} catch (err) {
|
||||
return {
|
||||
label: query.label,
|
||||
params: query.params,
|
||||
tmdbCount: 0,
|
||||
localCount: 0,
|
||||
localMatches: [],
|
||||
error: err.message
|
||||
};
|
||||
}
|
||||
})
|
||||
);
|
||||
|
||||
const resultSets = [
|
||||
...seedContexts.flatMap((context) => context.resultSets),
|
||||
...queryResults.map((query) => ({
|
||||
items: query.localMatches,
|
||||
sourceWeight: query.sourceWeight || 1,
|
||||
label: query.label
|
||||
}))
|
||||
].filter((resultSet) => (Array.isArray(resultSet) ? resultSet.length : resultSet.items.length) > 0);
|
||||
|
||||
const candidateInspection = inspectCandidateSets(excludedIds, resultSets);
|
||||
const recommendations = rankRecommendationResults(normalizedSeedIds, resultSets, {
|
||||
limit,
|
||||
profile,
|
||||
seeds,
|
||||
excludeIds: excludedIds,
|
||||
allowedTypes
|
||||
});
|
||||
|
||||
return {
|
||||
seeds,
|
||||
recommendations,
|
||||
diagnostics: {
|
||||
libraryItemCount: libraryItems.length,
|
||||
watchedItemCount: playedItems.length,
|
||||
seedCount: seeds.length,
|
||||
embyCandidates: seedContexts.reduce(
|
||||
(total, context) => total + context.diagnostic.localSimilarCount + context.diagnostic.localRecommendationCount,
|
||||
0
|
||||
),
|
||||
tmdbEnabled: true,
|
||||
tmdbCandidates:
|
||||
seedContexts.reduce(
|
||||
(total, context) => total + context.diagnostic.similarCount + context.diagnostic.recommendationCount,
|
||||
0
|
||||
) + queryResults.reduce((total, query) => total + query.tmdbCount, 0),
|
||||
tmdbResolved:
|
||||
seedContexts.reduce(
|
||||
(total, context) => total + context.diagnostic.localSimilarCount + context.diagnostic.localRecommendationCount,
|
||||
0
|
||||
) + queryResults.reduce((total, query) => total + query.localCount, 0),
|
||||
uniqueCandidateCount: candidateInspection.uniqueCandidateCount,
|
||||
excludedSeedCandidateCount: candidateInspection.excludedSeedCandidateCount,
|
||||
sampleExcludedSeedCandidates: candidateInspection.sampleExcludedSeedCandidates,
|
||||
perSeed: seedContexts.map((context) => context.diagnostic),
|
||||
discoverQueries: queryResults.map((query) => ({
|
||||
label: query.label,
|
||||
tmdbCount: query.tmdbCount,
|
||||
localCount: query.localCount,
|
||||
error: query.error || null,
|
||||
params: query.params
|
||||
}))
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
async function createOrUpdateCollection(userId, name, itemIds) {
|
||||
const existingCollection = await findExistingCollection(userId, name);
|
||||
|
||||
if (existingCollection?.id) {
|
||||
await fetchEmby(`/Collections/${encodeURIComponent(existingCollection.id)}/Items`, {
|
||||
method: 'POST',
|
||||
params: {
|
||||
Ids: itemIds.join(',')
|
||||
}
|
||||
});
|
||||
|
||||
return {
|
||||
id: existingCollection.id,
|
||||
name: existingCollection.name || name,
|
||||
updated: true
|
||||
};
|
||||
}
|
||||
|
||||
const response = await fetchEmby('/Collections', {
|
||||
method: 'POST',
|
||||
params: {
|
||||
Name: name,
|
||||
Ids: itemIds.join(',')
|
||||
}
|
||||
});
|
||||
const created = await response.json();
|
||||
|
||||
return {
|
||||
id: String(created?.Id || ''),
|
||||
name: created?.Name || name,
|
||||
updated: false
|
||||
};
|
||||
}
|
||||
|
||||
export async function POST({ request }) {
|
||||
const body = await request.json();
|
||||
const mode = body?.mode === 'create' ? 'create' : 'preview';
|
||||
const userId = normalizeEmbyGuid(body?.userId);
|
||||
const seedIds = Array.isArray(body?.seedIds) ? body.seedIds : [];
|
||||
const limit = Math.min(Math.max(Number(body?.limit || 18), 1), 48);
|
||||
const includeSeeds = body?.includeSeeds !== false;
|
||||
const name = String(body?.name || '').trim();
|
||||
const profile = RECOMMENDATION_PROFILES[body?.profile] ? body.profile : 'balanced';
|
||||
|
||||
if (!userId) {
|
||||
throw error(400, 'Missing userId');
|
||||
}
|
||||
|
||||
if (seedIds.length === 0) {
|
||||
throw error(400, 'Select at least one seed item');
|
||||
}
|
||||
|
||||
try {
|
||||
const preview = await buildPreview(userId, seedIds, limit, profile);
|
||||
const existingCollection = name ? await findExistingCollection(userId, name) : null;
|
||||
|
||||
if (mode !== 'create') {
|
||||
return json({
|
||||
...preview,
|
||||
profile,
|
||||
collection: existingCollection
|
||||
? {
|
||||
id: existingCollection.id,
|
||||
name: existingCollection.name,
|
||||
updated: true
|
||||
}
|
||||
: null
|
||||
});
|
||||
}
|
||||
|
||||
if (!name) {
|
||||
throw error(400, 'Collection name is required');
|
||||
}
|
||||
|
||||
const collectionIds = [
|
||||
...(includeSeeds ? preview.seeds.map((item) => item.id) : []),
|
||||
...preview.recommendations.map((item) => item.id)
|
||||
];
|
||||
const uniqueIds = [...new Set(collectionIds.filter(Boolean))];
|
||||
|
||||
if (uniqueIds.length === 0) {
|
||||
throw error(400, 'No items were available to add to the collection');
|
||||
}
|
||||
|
||||
const collection = await createOrUpdateCollection(userId, name, uniqueIds);
|
||||
|
||||
return json({
|
||||
seeds: preview.seeds,
|
||||
recommendations: preview.recommendations,
|
||||
profile,
|
||||
collection
|
||||
});
|
||||
} catch (err) {
|
||||
if (err?.status) throw err;
|
||||
if (String(err.message || '').includes('not configured')) {
|
||||
throw error(400, err.message);
|
||||
}
|
||||
throw error(502, `Could not build Emby collection: ${err.message}`);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user