timothyandClaude Opus 4.8
f869dfe87a
Adds a paged collection-items endpoint reusing LibraryBrowseItemResponseModel
so the SPA lists a manual collection's full contents (all media kinds), replacing
the lossy Lucene name-based preview. Confirms POST /items already returns 422 for
bogus ids (guarded by ValidateMediaItems, fb3f2856); adds endpoint-level coverage.
fixes #155
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
905 lines
36 KiB
C#
905 lines
36 KiB
C#
using ErsatzTV.Core.Api.LibraryBrowse;
|
|
using ErsatzTV.Core.Domain;
|
|
using ErsatzTV.Core.Interfaces.Search;
|
|
using ErsatzTV.Core.Search;
|
|
using ErsatzTV.Infrastructure.Data;
|
|
using ErsatzTV.Infrastructure.Search;
|
|
using Microsoft.EntityFrameworkCore;
|
|
|
|
namespace ErsatzTV.Application.LibraryBrowse;
|
|
|
|
public class GetLibraryBrowseItemsHandler(
|
|
ISearchIndex searchIndex,
|
|
IDbContextFactory<TvContext> dbContextFactory)
|
|
: IRequestHandler<GetLibraryBrowseItems, PagedLibraryBrowseItemsResponseModel>
|
|
{
|
|
private const string LibraryIdField = "library_id";
|
|
|
|
public async Task<PagedLibraryBrowseItemsResponseModel> Handle(
|
|
GetLibraryBrowseItems request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
// Drill-in for detail pages: read a parent's children directly (bypassing Lucene) so the SPA can
|
|
// expand a show into its seasons (#180), a season into its episodes, or an artist into its music
|
|
// videos (#141/#161). Each reads in the natural display order for that kind.
|
|
if (request.ParentId.HasValue)
|
|
{
|
|
switch (request.MediaType)
|
|
{
|
|
case LibraryBrowseMediaType.TelevisionSeason:
|
|
{
|
|
await using TvContext seasonContext =
|
|
await dbContextFactory.CreateDbContextAsync(cancellationToken);
|
|
return await BrowseSeasonsForShow(seasonContext, request, cancellationToken);
|
|
}
|
|
case LibraryBrowseMediaType.Episode:
|
|
{
|
|
await using TvContext episodeContext =
|
|
await dbContextFactory.CreateDbContextAsync(cancellationToken);
|
|
return await BrowseEpisodesForSeason(episodeContext, request, cancellationToken);
|
|
}
|
|
case LibraryBrowseMediaType.MusicVideo:
|
|
{
|
|
await using TvContext musicVideoContext =
|
|
await dbContextFactory.CreateDbContextAsync(cancellationToken);
|
|
return await BrowseMusicVideosForArtist(musicVideoContext, request, cancellationToken);
|
|
}
|
|
}
|
|
}
|
|
|
|
int offset = request.PageNum * request.PageSize;
|
|
SearchResult mediaResult = await SearchMedia(request, offset, request.PageSize, cancellationToken);
|
|
|
|
await using TvContext dbContext = await dbContextFactory.CreateDbContextAsync(cancellationToken);
|
|
|
|
List<LibraryBrowseItemResponseModel> mediaItems = await HydrateMediaItems(
|
|
dbContext,
|
|
mediaResult.Items,
|
|
cancellationToken);
|
|
|
|
int collectionTotal = await CountCollections(dbContext, request, cancellationToken);
|
|
// Lucene total count can briefly include stale media ids until the async rescan catches up; collection
|
|
// paging may drift in that window, matching the staleness behavior accepted by the existing search UI.
|
|
int collectionSkip = Math.Max(0, offset - mediaResult.TotalCount);
|
|
int collectionTake = request.PageSize - mediaItems.Count;
|
|
List<LibraryBrowseItemResponseModel> collectionItems = collectionTake > 0
|
|
? await GetCollectionItems(dbContext, request, collectionSkip, collectionTake, cancellationToken)
|
|
: [];
|
|
|
|
return new PagedLibraryBrowseItemsResponseModel(
|
|
mediaResult.TotalCount + collectionTotal,
|
|
mediaItems.Concat(collectionItems).ToList());
|
|
}
|
|
|
|
private async Task<SearchResult> SearchMedia(
|
|
GetLibraryBrowseItems request,
|
|
int offset,
|
|
int pageSize,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
List<string> typeFilters = MediaTypesFor(request.MediaType).ToList();
|
|
if (typeFilters.Count == 0)
|
|
{
|
|
return new SearchResult([], 0);
|
|
}
|
|
|
|
var clauses = new List<string>
|
|
{
|
|
typeFilters.Count == 1
|
|
? $"type:{typeFilters[0]}"
|
|
: $"({string.Join(" OR ", typeFilters.Map(t => $"type:{t}"))})"
|
|
};
|
|
|
|
if (request.LibraryId.HasValue)
|
|
{
|
|
clauses.Add($"{LibraryIdField}:{request.LibraryId.Value}");
|
|
}
|
|
|
|
if (!string.IsNullOrWhiteSpace(request.Query))
|
|
{
|
|
clauses.Add($"({request.Query})");
|
|
}
|
|
|
|
return await searchIndex.Search(
|
|
string.Join(" AND ", clauses),
|
|
string.Empty,
|
|
offset,
|
|
pageSize,
|
|
[LuceneSearchIndex.TitleAndYearSearchField],
|
|
cancellationToken);
|
|
}
|
|
|
|
private static IEnumerable<string> MediaTypesFor(LibraryBrowseMediaType? mediaType) =>
|
|
mediaType switch
|
|
{
|
|
LibraryBrowseMediaType.Movie => [LuceneSearchIndex.MovieType],
|
|
LibraryBrowseMediaType.TelevisionShow => [LuceneSearchIndex.ShowType],
|
|
LibraryBrowseMediaType.TelevisionSeason => [LuceneSearchIndex.SeasonType],
|
|
LibraryBrowseMediaType.Artist => [LuceneSearchIndex.ArtistType],
|
|
LibraryBrowseMediaType.Episode => [LuceneSearchIndex.EpisodeType],
|
|
LibraryBrowseMediaType.MusicVideo => [LuceneSearchIndex.MusicVideoType],
|
|
LibraryBrowseMediaType.Song => [LuceneSearchIndex.SongType],
|
|
LibraryBrowseMediaType.OtherVideo => [LuceneSearchIndex.OtherVideoType],
|
|
LibraryBrowseMediaType.Image => [LuceneSearchIndex.ImageType],
|
|
LibraryBrowseMediaType.RemoteStream => [LuceneSearchIndex.RemoteStreamType],
|
|
null =>
|
|
[
|
|
LuceneSearchIndex.MovieType,
|
|
LuceneSearchIndex.ShowType,
|
|
LuceneSearchIndex.SeasonType,
|
|
LuceneSearchIndex.ArtistType,
|
|
LuceneSearchIndex.EpisodeType,
|
|
LuceneSearchIndex.MusicVideoType,
|
|
LuceneSearchIndex.SongType,
|
|
LuceneSearchIndex.OtherVideoType,
|
|
LuceneSearchIndex.ImageType,
|
|
LuceneSearchIndex.RemoteStreamType
|
|
],
|
|
_ => []
|
|
};
|
|
|
|
private static async Task<List<LibraryBrowseItemResponseModel>> HydrateMediaItems(
|
|
TvContext dbContext,
|
|
List<SearchItem> searchItems,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (searchItems.Count == 0)
|
|
{
|
|
return [];
|
|
}
|
|
|
|
List<int> movieIds = searchItems.Where(i => i.Type == LuceneSearchIndex.MovieType).Select(i => i.Id).ToList();
|
|
List<int> showIds = searchItems.Where(i => i.Type == LuceneSearchIndex.ShowType).Select(i => i.Id).ToList();
|
|
List<int> seasonIds = searchItems.Where(i => i.Type == LuceneSearchIndex.SeasonType).Select(i => i.Id).ToList();
|
|
List<int> artistIds = searchItems.Where(i => i.Type == LuceneSearchIndex.ArtistType).Select(i => i.Id).ToList();
|
|
List<int> episodeIds = searchItems.Where(i => i.Type == LuceneSearchIndex.EpisodeType).Select(i => i.Id).ToList();
|
|
List<int> musicVideoIds =
|
|
searchItems.Where(i => i.Type == LuceneSearchIndex.MusicVideoType).Select(i => i.Id).ToList();
|
|
List<int> songIds = searchItems.Where(i => i.Type == LuceneSearchIndex.SongType).Select(i => i.Id).ToList();
|
|
List<int> otherVideoIds =
|
|
searchItems.Where(i => i.Type == LuceneSearchIndex.OtherVideoType).Select(i => i.Id).ToList();
|
|
List<int> imageIds = searchItems.Where(i => i.Type == LuceneSearchIndex.ImageType).Select(i => i.Id).ToList();
|
|
List<int> remoteStreamIds =
|
|
searchItems.Where(i => i.Type == LuceneSearchIndex.RemoteStreamType).Select(i => i.Id).ToList();
|
|
|
|
Dictionary<(string Type, int Id), LibraryBrowseItemResponseModel> hydrated = [];
|
|
|
|
foreach (LibraryBrowseItemResponseModel item in
|
|
await LibraryBrowseItemMapper.GetMovies(dbContext, movieIds, cancellationToken))
|
|
{
|
|
hydrated[(LuceneSearchIndex.MovieType, item.Id)] = item;
|
|
}
|
|
|
|
foreach (LibraryBrowseItemResponseModel item in
|
|
await LibraryBrowseItemMapper.GetShows(dbContext, showIds, cancellationToken))
|
|
{
|
|
hydrated[(LuceneSearchIndex.ShowType, item.Id)] = item;
|
|
}
|
|
|
|
foreach (LibraryBrowseItemResponseModel item in
|
|
await LibraryBrowseItemMapper.GetSeasons(dbContext, seasonIds, cancellationToken))
|
|
{
|
|
hydrated[(LuceneSearchIndex.SeasonType, item.Id)] = item;
|
|
}
|
|
|
|
foreach (LibraryBrowseItemResponseModel item in
|
|
await LibraryBrowseItemMapper.GetArtists(dbContext, artistIds, cancellationToken))
|
|
{
|
|
hydrated[(LuceneSearchIndex.ArtistType, item.Id)] = item;
|
|
}
|
|
|
|
foreach (LibraryBrowseItemResponseModel item in
|
|
await LibraryBrowseItemMapper.GetEpisodes(dbContext, episodeIds, cancellationToken))
|
|
{
|
|
hydrated[(LuceneSearchIndex.EpisodeType, item.Id)] = item;
|
|
}
|
|
|
|
foreach (LibraryBrowseItemResponseModel item in
|
|
await LibraryBrowseItemMapper.GetMusicVideos(dbContext, musicVideoIds, cancellationToken))
|
|
{
|
|
hydrated[(LuceneSearchIndex.MusicVideoType, item.Id)] = item;
|
|
}
|
|
|
|
foreach (LibraryBrowseItemResponseModel item in
|
|
await LibraryBrowseItemMapper.GetSongs(dbContext, songIds, cancellationToken))
|
|
{
|
|
hydrated[(LuceneSearchIndex.SongType, item.Id)] = item;
|
|
}
|
|
|
|
foreach (LibraryBrowseItemResponseModel item in
|
|
await LibraryBrowseItemMapper.GetOtherVideos(dbContext, otherVideoIds, cancellationToken))
|
|
{
|
|
hydrated[(LuceneSearchIndex.OtherVideoType, item.Id)] = item;
|
|
}
|
|
|
|
foreach (LibraryBrowseItemResponseModel item in
|
|
await LibraryBrowseItemMapper.GetImages(dbContext, imageIds, cancellationToken))
|
|
{
|
|
hydrated[(LuceneSearchIndex.ImageType, item.Id)] = item;
|
|
}
|
|
|
|
foreach (LibraryBrowseItemResponseModel item in
|
|
await LibraryBrowseItemMapper.GetRemoteStreams(dbContext, remoteStreamIds, cancellationToken))
|
|
{
|
|
hydrated[(LuceneSearchIndex.RemoteStreamType, item.Id)] = item;
|
|
}
|
|
|
|
return searchItems
|
|
.Where(i => hydrated.ContainsKey((i.Type, i.Id)))
|
|
.Select(i => hydrated[(i.Type, i.Id)])
|
|
.ToList();
|
|
}
|
|
|
|
private static async Task<PagedLibraryBrowseItemsResponseModel> BrowseSeasonsForShow(
|
|
TvContext dbContext,
|
|
GetLibraryBrowseItems request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
List<int> allSeasonIds = await dbContext.Seasons
|
|
.AsNoTracking()
|
|
.Where(s => s.ShowId == request.ParentId.Value)
|
|
.OrderBy(s => s.SeasonNumber)
|
|
.Select(s => s.Id)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
int total = allSeasonIds.Count;
|
|
List<int> pageIds = allSeasonIds
|
|
.Skip(request.PageNum * request.PageSize)
|
|
.Take(request.PageSize)
|
|
.ToList();
|
|
|
|
List<LibraryBrowseItemResponseModel> seasons =
|
|
await LibraryBrowseItemMapper.GetSeasons(dbContext, pageIds, cancellationToken);
|
|
|
|
// GetSeasons groups by season id, so restore the requested season-number order.
|
|
Dictionary<int, LibraryBrowseItemResponseModel> byId = seasons.ToDictionary(s => s.Id);
|
|
List<LibraryBrowseItemResponseModel> ordered = pageIds
|
|
.Where(byId.ContainsKey)
|
|
.Select(id => byId[id])
|
|
.ToList();
|
|
|
|
return new PagedLibraryBrowseItemsResponseModel(total, ordered);
|
|
}
|
|
|
|
// Drill-in: episodes of a specific season, in episode-number order (#141/#161).
|
|
private static async Task<PagedLibraryBrowseItemsResponseModel> BrowseEpisodesForSeason(
|
|
TvContext dbContext,
|
|
GetLibraryBrowseItems request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
List<int> allEpisodeIds = await dbContext.EpisodeMetadata
|
|
.AsNoTracking()
|
|
.Where(em => em.Episode.SeasonId == request.ParentId.Value)
|
|
.OrderBy(em => em.EpisodeNumber)
|
|
.ThenBy(em => em.EpisodeId)
|
|
.Select(em => em.EpisodeId)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
// Distinct preserves order (LINQ-to-Objects) for episodes with multiple metadata rows.
|
|
allEpisodeIds = allEpisodeIds.Distinct().ToList();
|
|
|
|
int total = allEpisodeIds.Count;
|
|
List<int> pageIds = allEpisodeIds
|
|
.Skip(request.PageNum * request.PageSize)
|
|
.Take(request.PageSize)
|
|
.ToList();
|
|
|
|
List<LibraryBrowseItemResponseModel> episodes =
|
|
await LibraryBrowseItemMapper.GetEpisodes(dbContext, pageIds, cancellationToken);
|
|
|
|
Dictionary<int, LibraryBrowseItemResponseModel> byId = episodes.ToDictionary(e => e.Id);
|
|
List<LibraryBrowseItemResponseModel> ordered = pageIds
|
|
.Where(byId.ContainsKey)
|
|
.Select(id => byId[id])
|
|
.ToList();
|
|
|
|
return new PagedLibraryBrowseItemsResponseModel(total, ordered);
|
|
}
|
|
|
|
// Drill-in: music videos of a specific artist, in album/track/title order (#141/#161).
|
|
private static async Task<PagedLibraryBrowseItemsResponseModel> BrowseMusicVideosForArtist(
|
|
TvContext dbContext,
|
|
GetLibraryBrowseItems request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
List<int> allMusicVideoIds = await dbContext.MusicVideoMetadata
|
|
.AsNoTracking()
|
|
.Where(mvm => mvm.MusicVideo.ArtistId == request.ParentId.Value)
|
|
.OrderBy(mvm => mvm.Album)
|
|
.ThenBy(mvm => mvm.Track)
|
|
.ThenBy(mvm => mvm.Title)
|
|
.ThenBy(mvm => mvm.MusicVideoId)
|
|
.Select(mvm => mvm.MusicVideoId)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
allMusicVideoIds = allMusicVideoIds.Distinct().ToList();
|
|
|
|
int total = allMusicVideoIds.Count;
|
|
List<int> pageIds = allMusicVideoIds
|
|
.Skip(request.PageNum * request.PageSize)
|
|
.Take(request.PageSize)
|
|
.ToList();
|
|
|
|
List<LibraryBrowseItemResponseModel> musicVideos =
|
|
await LibraryBrowseItemMapper.GetMusicVideos(dbContext, pageIds, cancellationToken);
|
|
|
|
Dictionary<int, LibraryBrowseItemResponseModel> byId = musicVideos.ToDictionary(mv => mv.Id);
|
|
List<LibraryBrowseItemResponseModel> ordered = pageIds
|
|
.Where(byId.ContainsKey)
|
|
.Select(id => byId[id])
|
|
.ToList();
|
|
|
|
return new PagedLibraryBrowseItemsResponseModel(total, ordered);
|
|
}
|
|
|
|
private static async Task<int> CountCollections(
|
|
TvContext dbContext,
|
|
GetLibraryBrowseItems request,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
int count = 0;
|
|
if (ShouldInclude(request.MediaType, LibraryBrowseMediaType.Collection))
|
|
{
|
|
count += await FilterCollections(dbContext.Collections.AsNoTracking(), request)
|
|
.CountAsync(cancellationToken);
|
|
}
|
|
|
|
if (!request.LibraryId.HasValue && ShouldInclude(request.MediaType, LibraryBrowseMediaType.SmartCollection))
|
|
{
|
|
count += await FilterByName(dbContext.SmartCollections.AsNoTracking(), request.Query)
|
|
.CountAsync(cancellationToken);
|
|
}
|
|
|
|
if (!request.LibraryId.HasValue && ShouldInclude(request.MediaType, LibraryBrowseMediaType.MultiCollection))
|
|
{
|
|
count += await FilterByName(dbContext.MultiCollections.AsNoTracking(), request.Query)
|
|
.CountAsync(cancellationToken);
|
|
}
|
|
|
|
if (!request.LibraryId.HasValue && ShouldInclude(request.MediaType, LibraryBrowseMediaType.RerunCollection))
|
|
{
|
|
count += await FilterByName(dbContext.RerunCollections.AsNoTracking(), request.Query)
|
|
.CountAsync(cancellationToken);
|
|
}
|
|
|
|
if (!request.LibraryId.HasValue && ShouldInclude(request.MediaType, LibraryBrowseMediaType.Playlist))
|
|
{
|
|
count += await FilterByName(dbContext.Playlists.AsNoTracking(), request.Query)
|
|
.CountAsync(cancellationToken);
|
|
}
|
|
|
|
return count;
|
|
}
|
|
|
|
private static async Task<List<LibraryBrowseItemResponseModel>> GetCollectionItems(
|
|
TvContext dbContext,
|
|
GetLibraryBrowseItems request,
|
|
int skip,
|
|
int take,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var results = new List<LibraryBrowseItemResponseModel>();
|
|
|
|
int remainingSkip = skip;
|
|
|
|
if (ShouldInclude(request.MediaType, LibraryBrowseMediaType.Collection))
|
|
{
|
|
IQueryable<Collection> collectionQuery = FilterCollections(dbContext.Collections.AsNoTracking(), request);
|
|
int count = await collectionQuery.CountAsync(cancellationToken);
|
|
int pageSkip = Math.Min(remainingSkip, count);
|
|
remainingSkip -= pageSkip;
|
|
|
|
List<Collection> collections = await collectionQuery
|
|
.OrderBy(c => c.Name)
|
|
.Skip(pageSkip)
|
|
.Take(take)
|
|
.ToListAsync(cancellationToken);
|
|
List<int> collectionIds = collections.Map(c => c.Id).ToList();
|
|
Dictionary<int, int> itemCounts = await dbContext.CollectionItems
|
|
.AsNoTracking()
|
|
.Where(ci => collectionIds.Contains(ci.CollectionId))
|
|
.GroupBy(ci => ci.CollectionId)
|
|
.Select(g => new { CollectionId = g.Key, Count = g.Count() })
|
|
.ToDictionaryAsync(g => g.CollectionId, g => g.Count, cancellationToken);
|
|
Dictionary<int, TimeSpan?> durations = await GetManualCollectionDurations(
|
|
dbContext,
|
|
collectionIds,
|
|
cancellationToken);
|
|
Dictionary<int, string> artwork = await GetManualCollectionArtwork(dbContext, collectionIds, cancellationToken);
|
|
|
|
results.AddRange(collections.Map(c => new LibraryBrowseItemResponseModel(
|
|
c.Id,
|
|
LibraryBrowseMediaType.Collection,
|
|
c.Name,
|
|
null,
|
|
null,
|
|
artwork.TryGetValue(c.Id, out string poster) ? poster : string.Empty,
|
|
durations.TryGetValue(c.Id, out TimeSpan? duration) ? duration : null,
|
|
itemCounts.TryGetValue(c.Id, out int itemCount) ? itemCount : 0,
|
|
"Manual",
|
|
CollectionType.Collection,
|
|
c.Id,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null)));
|
|
}
|
|
|
|
if (results.Count >= take || request.LibraryId.HasValue)
|
|
{
|
|
return results.Take(take).ToList();
|
|
}
|
|
|
|
remainingSkip = await AppendSmartCollections(dbContext, request, results, remainingSkip, take, cancellationToken);
|
|
remainingSkip = await AppendMultiCollections(dbContext, request, results, remainingSkip, take, cancellationToken);
|
|
remainingSkip = await AppendRerunCollections(dbContext, request, results, remainingSkip, take, cancellationToken);
|
|
await AppendPlaylists(dbContext, request, results, remainingSkip, take, cancellationToken);
|
|
return results.Take(take).ToList();
|
|
}
|
|
|
|
private static async Task<int> AppendSmartCollections(
|
|
TvContext dbContext,
|
|
GetLibraryBrowseItems request,
|
|
List<LibraryBrowseItemResponseModel> results,
|
|
int skip,
|
|
int take,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (!ShouldInclude(request.MediaType, LibraryBrowseMediaType.SmartCollection) || results.Count >= take)
|
|
{
|
|
return skip;
|
|
}
|
|
|
|
IQueryable<SmartCollection> query = FilterByName(dbContext.SmartCollections.AsNoTracking(), request.Query);
|
|
int count = await query.CountAsync(cancellationToken);
|
|
int pageSkip = Math.Min(skip, count);
|
|
|
|
List<SmartCollection> page = await query
|
|
.OrderBy(c => c.Name)
|
|
.Skip(pageSkip)
|
|
.Take(take - results.Count)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
results.AddRange(page.Map(c => new LibraryBrowseItemResponseModel(
|
|
c.Id,
|
|
LibraryBrowseMediaType.SmartCollection,
|
|
c.Name,
|
|
null,
|
|
null,
|
|
string.Empty,
|
|
null,
|
|
null,
|
|
"Smart",
|
|
CollectionType.SmartCollection,
|
|
null,
|
|
null,
|
|
c.Id,
|
|
null,
|
|
null,
|
|
null)));
|
|
|
|
return skip - pageSkip;
|
|
}
|
|
|
|
private static async Task<int> AppendMultiCollections(
|
|
TvContext dbContext,
|
|
GetLibraryBrowseItems request,
|
|
List<LibraryBrowseItemResponseModel> results,
|
|
int skip,
|
|
int take,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (!ShouldInclude(request.MediaType, LibraryBrowseMediaType.MultiCollection) || results.Count >= take)
|
|
{
|
|
return skip;
|
|
}
|
|
|
|
IQueryable<MultiCollection> query = FilterByName(dbContext.MultiCollections.AsNoTracking(), request.Query);
|
|
int count = await query.CountAsync(cancellationToken);
|
|
int pageSkip = Math.Min(skip, count);
|
|
|
|
List<MultiCollection> page = await query
|
|
.OrderBy(c => c.Name)
|
|
.Skip(pageSkip)
|
|
.Take(take - results.Count)
|
|
.ToListAsync(cancellationToken);
|
|
List<int> ids = page.Map(c => c.Id).ToList();
|
|
Dictionary<int, int> collectionCounts = await dbContext.Set<MultiCollectionItem>()
|
|
.AsNoTracking()
|
|
.Where(i => ids.Contains(i.MultiCollectionId))
|
|
.GroupBy(i => i.MultiCollectionId)
|
|
.Select(g => new { MultiCollectionId = g.Key, Count = g.Count() })
|
|
.ToDictionaryAsync(g => g.MultiCollectionId, g => g.Count, cancellationToken);
|
|
Dictionary<int, int> smartCollectionCounts = await dbContext.Set<MultiCollectionSmartItem>()
|
|
.AsNoTracking()
|
|
.Where(i => ids.Contains(i.MultiCollectionId))
|
|
.GroupBy(i => i.MultiCollectionId)
|
|
.Select(g => new { MultiCollectionId = g.Key, Count = g.Count() })
|
|
.ToDictionaryAsync(g => g.MultiCollectionId, g => g.Count, cancellationToken);
|
|
|
|
results.AddRange(page.Map(c => new LibraryBrowseItemResponseModel(
|
|
c.Id,
|
|
LibraryBrowseMediaType.MultiCollection,
|
|
c.Name,
|
|
null,
|
|
null,
|
|
string.Empty,
|
|
null,
|
|
(collectionCounts.TryGetValue(c.Id, out int collectionCount) ? collectionCount : 0) +
|
|
(smartCollectionCounts.TryGetValue(c.Id, out int smartCollectionCount) ? smartCollectionCount : 0),
|
|
"Multi",
|
|
CollectionType.MultiCollection,
|
|
null,
|
|
c.Id,
|
|
null,
|
|
null,
|
|
null,
|
|
null)));
|
|
|
|
return skip - pageSkip;
|
|
}
|
|
|
|
private static async Task<int> AppendRerunCollections(
|
|
TvContext dbContext,
|
|
GetLibraryBrowseItems request,
|
|
List<LibraryBrowseItemResponseModel> results,
|
|
int skip,
|
|
int take,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (!ShouldInclude(request.MediaType, LibraryBrowseMediaType.RerunCollection) || results.Count >= take)
|
|
{
|
|
return skip;
|
|
}
|
|
|
|
IQueryable<RerunCollection> query = FilterByName(dbContext.RerunCollections.AsNoTracking(), request.Query);
|
|
int count = await query.CountAsync(cancellationToken);
|
|
int pageSkip = Math.Min(skip, count);
|
|
|
|
List<RerunCollection> page = await query
|
|
.OrderBy(c => c.Name)
|
|
.Skip(pageSkip)
|
|
.Take(take - results.Count)
|
|
.ToListAsync(cancellationToken);
|
|
|
|
results.AddRange(page.Map(c => new LibraryBrowseItemResponseModel(
|
|
c.Id,
|
|
LibraryBrowseMediaType.RerunCollection,
|
|
c.Name,
|
|
null,
|
|
null,
|
|
string.Empty,
|
|
null,
|
|
null,
|
|
"Rerun",
|
|
// RerunFirstRun addresses the first-run side; the SPA can substitute RerunRerun for rerun schedule items.
|
|
CollectionType.RerunFirstRun,
|
|
null,
|
|
null,
|
|
null,
|
|
c.Id,
|
|
null,
|
|
null)));
|
|
|
|
return skip - pageSkip;
|
|
}
|
|
|
|
private static async Task AppendPlaylists(
|
|
TvContext dbContext,
|
|
GetLibraryBrowseItems request,
|
|
List<LibraryBrowseItemResponseModel> results,
|
|
int skip,
|
|
int take,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (!ShouldInclude(request.MediaType, LibraryBrowseMediaType.Playlist) || results.Count >= take)
|
|
{
|
|
return;
|
|
}
|
|
|
|
IQueryable<Playlist> query = FilterByName(dbContext.Playlists.AsNoTracking(), request.Query);
|
|
int count = await query.CountAsync(cancellationToken);
|
|
int pageSkip = Math.Min(skip, count);
|
|
|
|
List<Playlist> page = await query
|
|
.OrderBy(c => c.Name)
|
|
.Skip(pageSkip)
|
|
.Take(take - results.Count)
|
|
.ToListAsync(cancellationToken);
|
|
List<int> ids = page.Map(c => c.Id).ToList();
|
|
Dictionary<int, int> itemCounts = await dbContext.PlaylistItems
|
|
.AsNoTracking()
|
|
.Where(i => ids.Contains(i.PlaylistId))
|
|
.GroupBy(i => i.PlaylistId)
|
|
.Select(g => new { PlaylistId = g.Key, Count = g.Count() })
|
|
.ToDictionaryAsync(g => g.PlaylistId, g => g.Count, cancellationToken);
|
|
|
|
results.AddRange(page.Map(c => new LibraryBrowseItemResponseModel(
|
|
c.Id,
|
|
LibraryBrowseMediaType.Playlist,
|
|
c.Name,
|
|
null,
|
|
null,
|
|
string.Empty,
|
|
null,
|
|
itemCounts.TryGetValue(c.Id, out int itemCount) ? itemCount : 0,
|
|
null,
|
|
CollectionType.Playlist,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
null,
|
|
c.Id)));
|
|
}
|
|
|
|
private static IQueryable<Collection> FilterCollections(
|
|
IQueryable<Collection> query,
|
|
GetLibraryBrowseItems request)
|
|
{
|
|
query = FilterByName(query, request.Query);
|
|
if (request.LibraryId.HasValue)
|
|
{
|
|
query = query.Where(c => c.MediaItems.Any(mi => mi.LibraryPath.LibraryId == request.LibraryId.Value));
|
|
}
|
|
|
|
return query;
|
|
}
|
|
|
|
private static IQueryable<T> FilterByName<T>(IQueryable<T> query, string searchQuery)
|
|
where T : class
|
|
{
|
|
if (string.IsNullOrWhiteSpace(searchQuery))
|
|
{
|
|
return query;
|
|
}
|
|
|
|
return query.Where(c => EF.Functions.Like(EF.Property<string>(c, "Name"), $"%{EscapeLike(searchQuery)}%", "\\"));
|
|
}
|
|
|
|
private static bool ShouldInclude(LibraryBrowseMediaType? requestType, LibraryBrowseMediaType itemType) =>
|
|
requestType is null || requestType == itemType;
|
|
|
|
private static async Task<Dictionary<int, TimeSpan?>> GetManualCollectionDurations(
|
|
TvContext dbContext,
|
|
List<int> collectionIds,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
List<CollectionMediaItem> items = await GetCollectionMediaItems(dbContext, collectionIds, cancellationToken);
|
|
List<int> mediaItemIds = items.Map(i => i.MediaItemId).Distinct().ToList();
|
|
Dictionary<int, TimeSpan> mediaItemDurations = [];
|
|
|
|
foreach (Movie movie in await dbContext.Movies
|
|
.AsNoTracking()
|
|
.Where(m => mediaItemIds.Contains(m.Id))
|
|
.Include(m => m.MediaVersions)
|
|
.ToListAsync(cancellationToken))
|
|
{
|
|
TimeSpan? duration = LibraryBrowseItemMapper.BestDuration(movie.MediaVersions);
|
|
if (duration.HasValue)
|
|
{
|
|
mediaItemDurations[movie.Id] = duration.Value;
|
|
}
|
|
}
|
|
|
|
foreach (Episode episode in await dbContext.Episodes
|
|
.AsNoTracking()
|
|
.Where(e => mediaItemIds.Contains(e.Id))
|
|
.Include(e => e.MediaVersions)
|
|
.ToListAsync(cancellationToken))
|
|
{
|
|
TimeSpan? duration = LibraryBrowseItemMapper.BestDuration(episode.MediaVersions);
|
|
if (duration.HasValue)
|
|
{
|
|
mediaItemDurations[episode.Id] = duration.Value;
|
|
}
|
|
}
|
|
|
|
foreach (MusicVideo musicVideo in await dbContext.MusicVideos
|
|
.AsNoTracking()
|
|
.Where(mv => mediaItemIds.Contains(mv.Id))
|
|
.Include(mv => mv.MediaVersions)
|
|
.ToListAsync(cancellationToken))
|
|
{
|
|
TimeSpan? duration = LibraryBrowseItemMapper.BestDuration(musicVideo.MediaVersions);
|
|
if (duration.HasValue)
|
|
{
|
|
mediaItemDurations[musicVideo.Id] = duration.Value;
|
|
}
|
|
}
|
|
|
|
foreach (OtherVideo otherVideo in await dbContext.OtherVideos
|
|
.AsNoTracking()
|
|
.Where(ov => mediaItemIds.Contains(ov.Id))
|
|
.Include(ov => ov.MediaVersions)
|
|
.ToListAsync(cancellationToken))
|
|
{
|
|
TimeSpan? duration = LibraryBrowseItemMapper.BestDuration(otherVideo.MediaVersions);
|
|
if (duration.HasValue)
|
|
{
|
|
mediaItemDurations[otherVideo.Id] = duration.Value;
|
|
}
|
|
}
|
|
|
|
foreach (Song song in await dbContext.Songs
|
|
.AsNoTracking()
|
|
.Where(s => mediaItemIds.Contains(s.Id))
|
|
.Include(s => s.MediaVersions)
|
|
.ToListAsync(cancellationToken))
|
|
{
|
|
TimeSpan? duration = LibraryBrowseItemMapper.BestDuration(song.MediaVersions);
|
|
if (duration.HasValue)
|
|
{
|
|
mediaItemDurations[song.Id] = duration.Value;
|
|
}
|
|
}
|
|
|
|
foreach (Image image in await dbContext.Images
|
|
.AsNoTracking()
|
|
.Where(i => mediaItemIds.Contains(i.Id))
|
|
.Include(i => i.MediaVersions)
|
|
.ToListAsync(cancellationToken))
|
|
{
|
|
TimeSpan? duration = LibraryBrowseItemMapper.BestDuration(image.MediaVersions);
|
|
if (duration.HasValue)
|
|
{
|
|
mediaItemDurations[image.Id] = duration.Value;
|
|
}
|
|
}
|
|
|
|
foreach (RemoteStream remoteStream in await dbContext.RemoteStreams
|
|
.AsNoTracking()
|
|
.Where(rs => mediaItemIds.Contains(rs.Id))
|
|
.Include(rs => rs.MediaVersions)
|
|
.ToListAsync(cancellationToken))
|
|
{
|
|
TimeSpan? duration = LibraryBrowseItemMapper.BestDuration(remoteStream.MediaVersions);
|
|
if (duration.HasValue)
|
|
{
|
|
mediaItemDurations[remoteStream.Id] = duration.Value;
|
|
}
|
|
}
|
|
|
|
return items
|
|
.Where(i => mediaItemDurations.ContainsKey(i.MediaItemId))
|
|
.GroupBy(i => i.CollectionId)
|
|
.ToDictionary(
|
|
g => g.Key,
|
|
g => (TimeSpan?)g.Aggregate(TimeSpan.Zero, (sum, item) => sum + mediaItemDurations[item.MediaItemId]));
|
|
}
|
|
|
|
private static async Task<Dictionary<int, string>> GetManualCollectionArtwork(
|
|
TvContext dbContext,
|
|
List<int> collectionIds,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
List<CollectionMediaItem> items = await GetCollectionMediaItems(dbContext, collectionIds, cancellationToken);
|
|
List<int> mediaItemIds = items.Map(i => i.MediaItemId).Distinct().ToList();
|
|
Dictionary<int, string> mediaItemArtwork = [];
|
|
|
|
foreach (MovieMetadata metadata in await dbContext.MovieMetadata
|
|
.AsNoTracking()
|
|
.Where(mm => mediaItemIds.Contains(mm.MovieId))
|
|
.Include(mm => mm.Artwork)
|
|
.OrderBy(mm => mm.Id)
|
|
.ToListAsync(cancellationToken))
|
|
{
|
|
string poster = LibraryBrowseItemMapper.Artwork(metadata, ArtworkKind.Poster);
|
|
if (!string.IsNullOrWhiteSpace(poster) && !mediaItemArtwork.ContainsKey(metadata.MovieId))
|
|
{
|
|
mediaItemArtwork[metadata.MovieId] = poster;
|
|
}
|
|
}
|
|
|
|
foreach (ShowMetadata metadata in await dbContext.ShowMetadata
|
|
.AsNoTracking()
|
|
.Where(sm => mediaItemIds.Contains(sm.ShowId))
|
|
.Include(sm => sm.Artwork)
|
|
.OrderBy(sm => sm.Id)
|
|
.ToListAsync(cancellationToken))
|
|
{
|
|
string poster = LibraryBrowseItemMapper.Artwork(metadata, ArtworkKind.Poster);
|
|
if (!string.IsNullOrWhiteSpace(poster) && !mediaItemArtwork.ContainsKey(metadata.ShowId))
|
|
{
|
|
mediaItemArtwork[metadata.ShowId] = poster;
|
|
}
|
|
}
|
|
|
|
foreach (SeasonMetadata metadata in await dbContext.SeasonMetadata
|
|
.AsNoTracking()
|
|
.Where(sm => mediaItemIds.Contains(sm.SeasonId))
|
|
.Include(sm => sm.Artwork)
|
|
.OrderBy(sm => sm.Id)
|
|
.ToListAsync(cancellationToken))
|
|
{
|
|
string poster = LibraryBrowseItemMapper.Artwork(metadata, ArtworkKind.Poster);
|
|
if (!string.IsNullOrWhiteSpace(poster) && !mediaItemArtwork.ContainsKey(metadata.SeasonId))
|
|
{
|
|
mediaItemArtwork[metadata.SeasonId] = poster;
|
|
}
|
|
}
|
|
|
|
foreach (OtherVideoMetadata metadata in await dbContext.OtherVideoMetadata
|
|
.AsNoTracking()
|
|
.Where(ovm => mediaItemIds.Contains(ovm.OtherVideoId))
|
|
.Include(ovm => ovm.Artwork)
|
|
.OrderBy(ovm => ovm.Id)
|
|
.ToListAsync(cancellationToken))
|
|
{
|
|
string poster = LibraryBrowseItemMapper.Artwork(metadata, ArtworkKind.Poster);
|
|
if (!string.IsNullOrWhiteSpace(poster) && !mediaItemArtwork.ContainsKey(metadata.OtherVideoId))
|
|
{
|
|
mediaItemArtwork[metadata.OtherVideoId] = poster;
|
|
}
|
|
}
|
|
|
|
foreach (SongMetadata metadata in await dbContext.SongMetadata
|
|
.AsNoTracking()
|
|
.Where(sm => mediaItemIds.Contains(sm.SongId))
|
|
.Include(sm => sm.Artwork)
|
|
.OrderBy(sm => sm.Id)
|
|
.ToListAsync(cancellationToken))
|
|
{
|
|
string poster = LibraryBrowseItemMapper.Artwork(metadata, ArtworkKind.Poster);
|
|
if (!string.IsNullOrWhiteSpace(poster) && !mediaItemArtwork.ContainsKey(metadata.SongId))
|
|
{
|
|
mediaItemArtwork[metadata.SongId] = poster;
|
|
}
|
|
}
|
|
|
|
foreach (ImageMetadata metadata in await dbContext.ImageMetadata
|
|
.AsNoTracking()
|
|
.Where(im => mediaItemIds.Contains(im.ImageId))
|
|
.Include(im => im.Artwork)
|
|
.OrderBy(im => im.Id)
|
|
.ToListAsync(cancellationToken))
|
|
{
|
|
string poster = LibraryBrowseItemMapper.Artwork(metadata, ArtworkKind.Poster);
|
|
if (!string.IsNullOrWhiteSpace(poster) && !mediaItemArtwork.ContainsKey(metadata.ImageId))
|
|
{
|
|
mediaItemArtwork[metadata.ImageId] = poster;
|
|
}
|
|
}
|
|
|
|
foreach (RemoteStreamMetadata metadata in await dbContext.RemoteStreamMetadata
|
|
.AsNoTracking()
|
|
.Where(rsm => mediaItemIds.Contains(rsm.RemoteStreamId))
|
|
.Include(rsm => rsm.Artwork)
|
|
.OrderBy(rsm => rsm.Id)
|
|
.ToListAsync(cancellationToken))
|
|
{
|
|
string poster = LibraryBrowseItemMapper.Artwork(metadata, ArtworkKind.Poster);
|
|
if (!string.IsNullOrWhiteSpace(poster) && !mediaItemArtwork.ContainsKey(metadata.RemoteStreamId))
|
|
{
|
|
mediaItemArtwork[metadata.RemoteStreamId] = poster;
|
|
}
|
|
}
|
|
|
|
return items
|
|
.Where(i => mediaItemArtwork.ContainsKey(i.MediaItemId))
|
|
.GroupBy(i => i.CollectionId)
|
|
.ToDictionary(
|
|
g => g.Key,
|
|
g => mediaItemArtwork[g.OrderBy(i => i.CustomIndex ?? int.MaxValue).ThenBy(i => i.MediaItemId).First().MediaItemId]);
|
|
}
|
|
|
|
private static async Task<List<CollectionMediaItem>> GetCollectionMediaItems(
|
|
TvContext dbContext,
|
|
List<int> collectionIds,
|
|
CancellationToken cancellationToken) =>
|
|
await dbContext.CollectionItems
|
|
.AsNoTracking()
|
|
.Where(ci => collectionIds.Contains(ci.CollectionId))
|
|
.Select(ci => new CollectionMediaItem(ci.CollectionId, ci.MediaItemId, ci.CustomIndex))
|
|
.ToListAsync(cancellationToken);
|
|
|
|
private static string EscapeLike(string searchQuery) =>
|
|
searchQuery
|
|
.Replace("\\", "\\\\", StringComparison.Ordinal)
|
|
.Replace("%", "\\%", StringComparison.Ordinal)
|
|
.Replace("_", "\\_", StringComparison.Ordinal);
|
|
|
|
private sealed record CollectionMediaItem(int CollectionId, int MediaItemId, int? CustomIndex);
|
|
}
|