From 127a1307379f5dd9a07c7f4fb3874ab402799da3 Mon Sep 17 00:00:00 2001 From: Timothy Date: Mon, 6 Jul 2026 00:01:06 +0200 Subject: [PATCH 1/2] feat(api): add library browse endpoint refs #65 --- .../Queries/GetLibraryBrowseItems.cs | 10 + .../Queries/GetLibraryBrowseItemsHandler.cs | 688 ++++++++++++++++++ .../LibraryBrowseItemResponseModel.cs | 22 + .../LibraryBrowse/LibraryBrowseMediaType.cs | 15 + .../PagedLibraryBrowseItemsResponseModel.cs | 6 + .../GetLibraryBrowseItemsHandlerTests.cs | 284 ++++++++ .../LibraryBrowseControllerTests.cs | 92 +++ .../Api/LibraryBrowseController.cs | 33 + ErsatzTV/wwwroot/openapi/v1.json | 224 ++++++ web/src/api/generated/v1.d.ts | 23 + 10 files changed, 1397 insertions(+) create mode 100644 ErsatzTV.Application/LibraryBrowse/Queries/GetLibraryBrowseItems.cs create mode 100644 ErsatzTV.Application/LibraryBrowse/Queries/GetLibraryBrowseItemsHandler.cs create mode 100644 ErsatzTV.Core/Api/LibraryBrowse/LibraryBrowseItemResponseModel.cs create mode 100644 ErsatzTV.Core/Api/LibraryBrowse/LibraryBrowseMediaType.cs create mode 100644 ErsatzTV.Core/Api/LibraryBrowse/PagedLibraryBrowseItemsResponseModel.cs create mode 100644 ErsatzTV.Tests/Application/LibraryBrowse/GetLibraryBrowseItemsHandlerTests.cs create mode 100644 ErsatzTV.Tests/Controllers/LibraryBrowseControllerTests.cs create mode 100644 ErsatzTV/Controllers/Api/LibraryBrowseController.cs diff --git a/ErsatzTV.Application/LibraryBrowse/Queries/GetLibraryBrowseItems.cs b/ErsatzTV.Application/LibraryBrowse/Queries/GetLibraryBrowseItems.cs new file mode 100644 index 000000000..eb8a49d2e --- /dev/null +++ b/ErsatzTV.Application/LibraryBrowse/Queries/GetLibraryBrowseItems.cs @@ -0,0 +1,10 @@ +using ErsatzTV.Core.Api.LibraryBrowse; + +namespace ErsatzTV.Application.LibraryBrowse; + +public record GetLibraryBrowseItems( + string Query, + int? LibraryId, + LibraryBrowseMediaType? MediaType, + int PageNum, + int PageSize) : IRequest; diff --git a/ErsatzTV.Application/LibraryBrowse/Queries/GetLibraryBrowseItemsHandler.cs b/ErsatzTV.Application/LibraryBrowse/Queries/GetLibraryBrowseItemsHandler.cs new file mode 100644 index 000000000..5d759a7bd --- /dev/null +++ b/ErsatzTV.Application/LibraryBrowse/Queries/GetLibraryBrowseItemsHandler.cs @@ -0,0 +1,688 @@ +using ErsatzTV.Core.Api.LibraryBrowse; +using ErsatzTV.Core.Domain; +using ErsatzTV.Core.Emby; +using ErsatzTV.Core.Interfaces.Search; +using ErsatzTV.Core.Jellyfin; +using ErsatzTV.Core.Search; +using ErsatzTV.Infrastructure.Data; +using ErsatzTV.Infrastructure.Search; +using Flurl; +using Microsoft.EntityFrameworkCore; + +namespace ErsatzTV.Application.LibraryBrowse; + +public class GetLibraryBrowseItemsHandler( + ISearchIndex searchIndex, + IDbContextFactory dbContextFactory) + : IRequestHandler +{ + private const string LibraryIdField = "library_id"; + + public async Task Handle( + GetLibraryBrowseItems request, + CancellationToken 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 mediaItems = await HydrateMediaItems( + dbContext, + mediaResult.Items, + cancellationToken); + + int collectionTotal = await CountCollections(dbContext, request, cancellationToken); + int collectionSkip = Math.Max(0, offset - mediaResult.TotalCount); + int collectionTake = request.PageSize - mediaItems.Count; + List collectionItems = collectionTake > 0 + ? await GetCollectionItems(dbContext, request, collectionSkip, collectionTake, cancellationToken) + : []; + + return new PagedLibraryBrowseItemsResponseModel( + mediaResult.TotalCount + collectionTotal, + mediaItems.Concat(collectionItems).ToList()); + } + + private async Task SearchMedia( + GetLibraryBrowseItems request, + int offset, + int pageSize, + CancellationToken cancellationToken) + { + List typeFilters = MediaTypesFor(request.MediaType).ToList(); + if (typeFilters.Count == 0) + { + return new SearchResult([], 0); + } + + var clauses = new List + { + 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 MediaTypesFor(LibraryBrowseMediaType? mediaType) => + mediaType switch + { + LibraryBrowseMediaType.Movie => [LuceneSearchIndex.MovieType], + LibraryBrowseMediaType.TelevisionShow => [LuceneSearchIndex.ShowType], + LibraryBrowseMediaType.TelevisionSeason => [LuceneSearchIndex.SeasonType], + LibraryBrowseMediaType.Artist => [LuceneSearchIndex.ArtistType], + null => + [ + LuceneSearchIndex.MovieType, + LuceneSearchIndex.ShowType, + LuceneSearchIndex.SeasonType, + LuceneSearchIndex.ArtistType + ], + _ => [] + }; + + private static async Task> HydrateMediaItems( + TvContext dbContext, + List searchItems, + CancellationToken cancellationToken) + { + if (searchItems.Count == 0) + { + return []; + } + + List movieIds = searchItems.Where(i => i.Type == LuceneSearchIndex.MovieType).Select(i => i.Id).ToList(); + List showIds = searchItems.Where(i => i.Type == LuceneSearchIndex.ShowType).Select(i => i.Id).ToList(); + List seasonIds = searchItems.Where(i => i.Type == LuceneSearchIndex.SeasonType).Select(i => i.Id).ToList(); + List artistIds = searchItems.Where(i => i.Type == LuceneSearchIndex.ArtistType).Select(i => i.Id).ToList(); + + Dictionary<(string Type, int Id), LibraryBrowseItemResponseModel> hydrated = []; + + foreach (LibraryBrowseItemResponseModel item in await GetMovies(dbContext, movieIds, cancellationToken)) + { + hydrated[(LuceneSearchIndex.MovieType, item.Id)] = item; + } + + foreach (LibraryBrowseItemResponseModel item in await GetShows(dbContext, showIds, cancellationToken)) + { + hydrated[(LuceneSearchIndex.ShowType, item.Id)] = item; + } + + foreach (LibraryBrowseItemResponseModel item in await GetSeasons(dbContext, seasonIds, cancellationToken)) + { + hydrated[(LuceneSearchIndex.SeasonType, item.Id)] = item; + } + + foreach (LibraryBrowseItemResponseModel item in await GetArtists(dbContext, artistIds, cancellationToken)) + { + hydrated[(LuceneSearchIndex.ArtistType, 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> GetMovies( + TvContext dbContext, + List ids, + CancellationToken cancellationToken) + { + if (ids.Count == 0) + { + return []; + } + + return await dbContext.MovieMetadata + .AsNoTracking() + .Where(mm => ids.Contains(mm.MovieId)) + .Include(mm => mm.Artwork) + .Include(mm => mm.Movie) + .ThenInclude(m => m.LibraryPath) + .ThenInclude(lp => lp.Library) + .Include(mm => mm.Movie) + .ThenInclude(m => m.MediaVersions) + .ToListAsync(cancellationToken) + .Map(list => list.Map(mm => new LibraryBrowseItemResponseModel( + mm.MovieId, + LibraryBrowseMediaType.Movie, + mm.Title ?? string.Empty, + mm.Movie.LibraryPath.LibraryId, + mm.Movie.LibraryPath.Library.Name, + Artwork(mm, ArtworkKind.Poster), + BestDuration(mm.Movie.MediaVersions), + 1, + null, + CollectionType.Movie, + null, + null, + null, + null, + mm.MovieId, + null)).ToList()); + } + + private static async Task> GetShows( + TvContext dbContext, + List ids, + CancellationToken cancellationToken) + { + if (ids.Count == 0) + { + return []; + } + + Dictionary counts = await dbContext.Episodes + .AsNoTracking() + .Where(e => ids.Contains(e.Season.ShowId)) + .GroupBy(e => e.Season.ShowId) + .Select(g => new { ShowId = g.Key, Count = g.Count() }) + .ToDictionaryAsync(g => g.ShowId, g => g.Count, cancellationToken); + + return await dbContext.ShowMetadata + .AsNoTracking() + .Where(sm => ids.Contains(sm.ShowId)) + .Include(sm => sm.Artwork) + .Include(sm => sm.Show) + .ThenInclude(s => s.LibraryPath) + .ThenInclude(lp => lp.Library) + .ToListAsync(cancellationToken) + .Map(list => list.Map(sm => new LibraryBrowseItemResponseModel( + sm.ShowId, + LibraryBrowseMediaType.TelevisionShow, + sm.Title ?? string.Empty, + sm.Show.LibraryPath.LibraryId, + sm.Show.LibraryPath.Library.Name, + Artwork(sm, ArtworkKind.Poster), + null, + counts.TryGetValue(sm.ShowId, out int count) ? count : 0, + null, + CollectionType.TelevisionShow, + null, + null, + null, + null, + sm.ShowId, + null)).ToList()); + } + + private static async Task> GetSeasons( + TvContext dbContext, + List ids, + CancellationToken cancellationToken) + { + if (ids.Count == 0) + { + return []; + } + + Dictionary counts = await dbContext.Episodes + .AsNoTracking() + .Where(e => ids.Contains(e.SeasonId)) + .GroupBy(e => e.SeasonId) + .Select(g => new { SeasonId = g.Key, Count = g.Count() }) + .ToDictionaryAsync(g => g.SeasonId, g => g.Count, cancellationToken); + + return await dbContext.SeasonMetadata + .AsNoTracking() + .Where(sm => ids.Contains(sm.SeasonId)) + .Include(sm => sm.Artwork) + .Include(sm => sm.Season) + .ThenInclude(s => s.Show) + .ThenInclude(s => s.ShowMetadata) + .Include(sm => sm.Season) + .ThenInclude(s => s.LibraryPath) + .ThenInclude(lp => lp.Library) + .ToListAsync(cancellationToken) + .Map(list => list.Map(sm => new LibraryBrowseItemResponseModel( + sm.SeasonId, + LibraryBrowseMediaType.TelevisionSeason, + SeasonTitle(sm), + sm.Season.LibraryPath.LibraryId, + sm.Season.LibraryPath.Library.Name, + Artwork(sm, ArtworkKind.Poster), + null, + counts.TryGetValue(sm.SeasonId, out int count) ? count : 0, + null, + CollectionType.TelevisionSeason, + null, + null, + null, + null, + sm.SeasonId, + null)).ToList()); + } + + private static async Task> GetArtists( + TvContext dbContext, + List ids, + CancellationToken cancellationToken) + { + if (ids.Count == 0) + { + return []; + } + + Dictionary counts = await dbContext.MusicVideos + .AsNoTracking() + .Where(mv => ids.Contains(mv.ArtistId)) + .GroupBy(mv => mv.ArtistId) + .Select(g => new { ArtistId = g.Key, Count = g.Count() }) + .ToDictionaryAsync(g => g.ArtistId, g => g.Count, cancellationToken); + + return await dbContext.ArtistMetadata + .AsNoTracking() + .Where(am => ids.Contains(am.ArtistId)) + .Include(am => am.Artwork) + .Include(am => am.Artist) + .ThenInclude(a => a.LibraryPath) + .ThenInclude(lp => lp.Library) + .ToListAsync(cancellationToken) + .Map(list => list.Map(am => new LibraryBrowseItemResponseModel( + am.ArtistId, + LibraryBrowseMediaType.Artist, + am.Title ?? string.Empty, + am.Artist.LibraryPath.LibraryId, + am.Artist.LibraryPath.Library.Name, + Artwork(am, ArtworkKind.Thumbnail), + null, + counts.TryGetValue(am.ArtistId, out int count) ? count : 0, + null, + CollectionType.Artist, + null, + null, + null, + null, + am.ArtistId, + null)).ToList()); + } + + private static async Task 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> GetCollectionItems( + TvContext dbContext, + GetLibraryBrowseItems request, + int skip, + int take, + CancellationToken cancellationToken) + { + var results = new List(); + + int remainingSkip = skip; + + if (ShouldInclude(request.MediaType, LibraryBrowseMediaType.Collection)) + { + IQueryable collectionQuery = FilterCollections(dbContext.Collections.AsNoTracking(), request); + int count = await collectionQuery.CountAsync(cancellationToken); + int pageSkip = Math.Min(remainingSkip, count); + remainingSkip -= pageSkip; + + List collections = await collectionQuery + .OrderBy(c => c.Name) + .Skip(pageSkip) + .Take(take) + .ToListAsync(cancellationToken); + List collectionIds = collections.Map(c => c.Id).ToList(); + Dictionary 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); + + results.AddRange(collections.Map(c => new LibraryBrowseItemResponseModel( + c.Id, + LibraryBrowseMediaType.Collection, + c.Name, + null, + null, + string.Empty, + 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 AppendSmartCollections( + TvContext dbContext, + GetLibraryBrowseItems request, + List results, + int skip, + int take, + CancellationToken cancellationToken) + { + if (!ShouldInclude(request.MediaType, LibraryBrowseMediaType.SmartCollection) || results.Count >= take) + { + return skip; + } + + IQueryable query = FilterByName(dbContext.SmartCollections.AsNoTracking(), request.Query); + int count = await query.CountAsync(cancellationToken); + int pageSkip = Math.Min(skip, count); + + List 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 AppendMultiCollections( + TvContext dbContext, + GetLibraryBrowseItems request, + List results, + int skip, + int take, + CancellationToken cancellationToken) + { + if (!ShouldInclude(request.MediaType, LibraryBrowseMediaType.MultiCollection) || results.Count >= take) + { + return skip; + } + + IQueryable query = FilterByName(dbContext.MultiCollections.AsNoTracking(), request.Query); + int count = await query.CountAsync(cancellationToken); + int pageSkip = Math.Min(skip, count); + + List page = await query + .OrderBy(c => c.Name) + .Skip(pageSkip) + .Take(take - results.Count) + .ToListAsync(cancellationToken); + List ids = page.Map(c => c.Id).ToList(); + Dictionary collectionCounts = await dbContext.Set() + .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 smartCollectionCounts = await dbContext.Set() + .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 AppendRerunCollections( + TvContext dbContext, + GetLibraryBrowseItems request, + List results, + int skip, + int take, + CancellationToken cancellationToken) + { + if (!ShouldInclude(request.MediaType, LibraryBrowseMediaType.RerunCollection) || results.Count >= take) + { + return skip; + } + + IQueryable query = FilterByName(dbContext.RerunCollections.AsNoTracking(), request.Query); + int count = await query.CountAsync(cancellationToken); + int pageSkip = Math.Min(skip, count); + + List 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", + CollectionType.RerunFirstRun, + null, + null, + null, + c.Id, + null, + null))); + + return skip - pageSkip; + } + + private static async Task AppendPlaylists( + TvContext dbContext, + GetLibraryBrowseItems request, + List results, + int skip, + int take, + CancellationToken cancellationToken) + { + if (!ShouldInclude(request.MediaType, LibraryBrowseMediaType.Playlist) || results.Count >= take) + { + return; + } + + IQueryable query = FilterByName(dbContext.Playlists.AsNoTracking(), request.Query); + int count = await query.CountAsync(cancellationToken); + int pageSkip = Math.Min(skip, count); + + List page = await query + .OrderBy(c => c.Name) + .Skip(pageSkip) + .Take(take - results.Count) + .ToListAsync(cancellationToken); + List ids = page.Map(c => c.Id).ToList(); + Dictionary 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 FilterCollections( + IQueryable 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 FilterByName(IQueryable query, string searchQuery) + where T : class + { + if (string.IsNullOrWhiteSpace(searchQuery)) + { + return query; + } + + return query.Where(c => EF.Functions.Like(EF.Property(c, "Name"), $"%{searchQuery}%")); + } + + private static bool ShouldInclude(LibraryBrowseMediaType? requestType, LibraryBrowseMediaType itemType) => + requestType is null || requestType == itemType; + + private static TimeSpan? BestDuration(IEnumerable versions) + { + TimeSpan duration = versions.Select(v => v.Duration).FirstOrDefault(d => d > TimeSpan.Zero); + return duration > TimeSpan.Zero ? duration : null; + } + + private static string SeasonTitle(SeasonMetadata metadata) + { + string showTitle = metadata.Season.Show.ShowMetadata.HeadOrNone() + .Map(sm => sm.Title ?? string.Empty) + .IfNone(string.Empty); + string seasonTitle = metadata.Season.SeasonNumber == 0 + ? "Specials" + : $"Season {metadata.Season.SeasonNumber}"; + return string.IsNullOrWhiteSpace(showTitle) ? seasonTitle : $"{showTitle} - {seasonTitle}"; + } + + private static string Artwork(Metadata metadata, ArtworkKind artworkKind) + { + string artwork = Optional(metadata.Artwork.FirstOrDefault(a => a.ArtworkKind == artworkKind)) + .Match(a => a.Path, string.Empty); + + if (artwork.StartsWith("jellyfin://", StringComparison.OrdinalIgnoreCase)) + { + Url url = JellyfinUrl.RelativeProxyForArtwork(artwork); + if (artworkKind is ArtworkKind.Poster or ArtworkKind.Thumbnail) + { + url.SetQueryParam("fillHeight", 440); + } + + return url; + } + + if (artwork.StartsWith("emby://", StringComparison.OrdinalIgnoreCase)) + { + Url url = EmbyUrl.RelativeProxyForArtwork(artwork); + if (artworkKind is ArtworkKind.Poster or ArtworkKind.Thumbnail) + { + url.SetQueryParam("maxHeight", 440); + } + + return url; + } + + return artwork; + } +} diff --git a/ErsatzTV.Core/Api/LibraryBrowse/LibraryBrowseItemResponseModel.cs b/ErsatzTV.Core/Api/LibraryBrowse/LibraryBrowseItemResponseModel.cs new file mode 100644 index 000000000..36ccfce41 --- /dev/null +++ b/ErsatzTV.Core/Api/LibraryBrowse/LibraryBrowseItemResponseModel.cs @@ -0,0 +1,22 @@ +#nullable enable +using ErsatzTV.Core.Domain; + +namespace ErsatzTV.Core.Api.LibraryBrowse; + +public record LibraryBrowseItemResponseModel( + int Id, + LibraryBrowseMediaType MediaType, + string Title, + int? LibraryId, + string? LibraryName, + string Artwork, + TimeSpan? Duration, + int? ItemCount, + string? CollectionKind, + CollectionType CollectionType, + int? CollectionId, + int? MultiCollectionId, + int? SmartCollectionId, + int? RerunCollectionId, + int? MediaItemId, + int? PlaylistId); diff --git a/ErsatzTV.Core/Api/LibraryBrowse/LibraryBrowseMediaType.cs b/ErsatzTV.Core/Api/LibraryBrowse/LibraryBrowseMediaType.cs new file mode 100644 index 000000000..1a12225a0 --- /dev/null +++ b/ErsatzTV.Core/Api/LibraryBrowse/LibraryBrowseMediaType.cs @@ -0,0 +1,15 @@ +#nullable enable +namespace ErsatzTV.Core.Api.LibraryBrowse; + +public enum LibraryBrowseMediaType +{ + Movie = 1, + TelevisionShow = 2, + TelevisionSeason = 3, + Artist = 4, + Collection = 5, + SmartCollection = 6, + MultiCollection = 7, + RerunCollection = 8, + Playlist = 9 +} diff --git a/ErsatzTV.Core/Api/LibraryBrowse/PagedLibraryBrowseItemsResponseModel.cs b/ErsatzTV.Core/Api/LibraryBrowse/PagedLibraryBrowseItemsResponseModel.cs new file mode 100644 index 000000000..831f82bf8 --- /dev/null +++ b/ErsatzTV.Core/Api/LibraryBrowse/PagedLibraryBrowseItemsResponseModel.cs @@ -0,0 +1,6 @@ +#nullable enable +namespace ErsatzTV.Core.Api.LibraryBrowse; + +public record PagedLibraryBrowseItemsResponseModel( + int TotalCount, + List Page); diff --git a/ErsatzTV.Tests/Application/LibraryBrowse/GetLibraryBrowseItemsHandlerTests.cs b/ErsatzTV.Tests/Application/LibraryBrowse/GetLibraryBrowseItemsHandlerTests.cs new file mode 100644 index 000000000..9bfaab26d --- /dev/null +++ b/ErsatzTV.Tests/Application/LibraryBrowse/GetLibraryBrowseItemsHandlerTests.cs @@ -0,0 +1,284 @@ +using ErsatzTV.Application.LibraryBrowse; +using ErsatzTV.Core.Api.LibraryBrowse; +using ErsatzTV.Core.Domain; +using ErsatzTV.Core.Interfaces.Metadata; +using ErsatzTV.Core.Interfaces.Repositories; +using ErsatzTV.Core.Interfaces.Search; +using ErsatzTV.Core.Search; +using ErsatzTV.Infrastructure.Data; +using ErsatzTV.Infrastructure.Search; +using ErsatzTV.Tests.Support; +using NSubstitute; +using NUnit.Framework; +using Shouldly; + +namespace ErsatzTV.Tests.Application.LibraryBrowse; + +[TestFixture] +public class GetLibraryBrowseItemsHandlerTests +{ + private InMemoryTvContext _db = null!; + private ISearchIndex _searchIndex = null!; + + [SetUp] + public async Task SetUp() + { + _db = await InMemoryTvContext.CreateAsync(); + _searchIndex = Substitute.For(); + } + + [TearDown] + public async Task TearDown() => await _db.DisposeAsync(); + + [Test] + public async Task Handle_Should_Search_Index_With_Type_Library_And_Title_Filters() + { + _searchIndex.Search( + Arg.Any(), + Arg.Any(), + Arg.Any(), + Arg.Any(), + Arg.Any>(), + Arg.Any()) + .Returns(new SearchResult([], 0)); + var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory); + + await handler.Handle( + new GetLibraryBrowseItems("star", 5, LibraryBrowseMediaType.Movie, 2, 25), + CancellationToken.None); + + await _searchIndex.Received(1).Search( + Arg.Is(q => q.Contains("type:movie") && q.Contains("library_id:5") && q.Contains("star")), + string.Empty, + 50, + 25, + Arg.Is>(fields => fields.SequenceEqual(new[] { LuceneSearchIndex.TitleAndYearSearchField })), + Arg.Any()); + } + + [Test] + public async Task Handle_Should_Hydrate_Media_Items_In_Search_Order_With_Artwork_Duration_And_Counts() + { + await SeedLibraryGraph(); + _searchIndex.Search( + Arg.Any(), + Arg.Any(), + Arg.Any(), + Arg.Any(), + Arg.Any>(), + Arg.Any()) + .Returns(new SearchResult( + [ + new SearchItem(LuceneSearchIndex.ShowType, 20), + new SearchItem(LuceneSearchIndex.MovieType, 10) + ], + 2)); + var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory); + + PagedLibraryBrowseItemsResponseModel result = await handler.Handle( + new GetLibraryBrowseItems("", null, null, 0, 10), + CancellationToken.None); + + result.TotalCount.ShouldBe(2); + result.Page[0].MediaType.ShouldBe(LibraryBrowseMediaType.TelevisionShow); + result.Page[0].Title.ShouldBe("Collision Show"); + result.Page[0].ItemCount.ShouldBe(1); + result.Page[0].MediaItemId.ShouldBe(20); + result.Page[1].MediaType.ShouldBe(LibraryBrowseMediaType.Movie); + result.Page[1].Title.ShouldBe("Collision Movie"); + result.Page[1].Artwork.ShouldBe("movie-poster.jpg"); + result.Page[1].Duration.ShouldBe(TimeSpan.FromMinutes(95)); + result.Page[1].MediaItemId.ShouldBe(10); + } + + [Test] + public async Task Handle_Should_Return_Typed_Collection_And_Playlist_Picker_Targets() + { + await SeedCollectionGraph(); + _searchIndex.Search( + Arg.Any(), + Arg.Any(), + Arg.Any(), + Arg.Any(), + Arg.Any>(), + Arg.Any()) + .Returns(new SearchResult([], 0)); + var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory); + + PagedLibraryBrowseItemsResponseModel result = await handler.Handle( + new GetLibraryBrowseItems("", null, null, 0, 10), + CancellationToken.None); + + result.TotalCount.ShouldBe(5); + result.Page.ShouldContain(i => + i.MediaType == LibraryBrowseMediaType.Collection && + i.CollectionKind == "Manual" && + i.CollectionType == CollectionType.Collection && + i.CollectionId == 20 && + i.ItemCount == 1); + result.Page.ShouldContain(i => + i.MediaType == LibraryBrowseMediaType.SmartCollection && + i.CollectionKind == "Smart" && + i.CollectionType == CollectionType.SmartCollection && + i.SmartCollectionId == 30); + result.Page.ShouldContain(i => + i.MediaType == LibraryBrowseMediaType.MultiCollection && + i.CollectionKind == "Multi" && + i.CollectionType == CollectionType.MultiCollection && + i.MultiCollectionId == 40); + result.Page.ShouldContain(i => + i.MediaType == LibraryBrowseMediaType.RerunCollection && + i.CollectionKind == "Rerun" && + i.CollectionType == CollectionType.RerunFirstRun && + i.RerunCollectionId == 50); + result.Page.ShouldContain(i => + i.MediaType == LibraryBrowseMediaType.Playlist && + i.CollectionType == CollectionType.Playlist && + i.PlaylistId == 60); + } + + private async Task SeedLibraryGraph() + { + await using TvContext context = _db.CreateContext(); + var library = new LocalLibrary + { + Id = 1, + Name = "Local Movies", + MediaKind = LibraryMediaKind.Movies, + Paths = [] + }; + var path = new LibraryPath + { + Id = 1, + Path = "/media", + Library = library, + LibraryFolders = [], + MediaItems = [] + }; + library.Paths.Add(path); + + var movie = new Movie + { + Id = 10, + LibraryPath = path, + Collections = [], + CollectionItems = [], + TraktListItems = [], + MediaVersions = [new MediaVersion { Duration = TimeSpan.FromMinutes(95) }], + MovieMetadata = + [ + MakeMovieMetadata("Collision Movie", "movie-poster.jpg") + ] + }; + var show = new Show + { + Id = 20, + LibraryPath = path, + Collections = [], + CollectionItems = [], + TraktListItems = [], + Seasons = [], + ShowMetadata = [MakeShowMetadata("Collision Show", "show-poster.jpg")] + }; + var season = new Season + { + Id = 11, + LibraryPath = path, + Show = show, + Collections = [], + CollectionItems = [], + TraktListItems = [], + Episodes = [], + SeasonMetadata = [] + }; + var episode = new Episode + { + Id = 12, + LibraryPath = path, + Season = season, + Collections = [], + CollectionItems = [], + TraktListItems = [], + EpisodeMetadata = [], + MediaVersions = [new MediaVersion { Duration = TimeSpan.FromMinutes(25) }] + }; + season.Episodes.Add(episode); + show.Seasons.Add(season); + path.MediaItems.AddRange([movie, show, season, episode]); + context.LocalLibraries.Add(library); + context.Movies.Add(movie); + context.Shows.Add(show); + context.Seasons.Add(season); + context.Episodes.Add(episode); + await context.SaveChangesAsync(); + } + + private async Task SeedCollectionGraph() + { + await using TvContext context = _db.CreateContext(); + var collection = new Collection { Id = 20, Name = "Manual", MediaItems = [], CollectionItems = [] }; + var movie = new Movie + { + Id = 21, + Collections = [collection], + CollectionItems = [], + TraktListItems = [], + MovieMetadata = [], + MediaVersions = [] + }; + collection.MediaItems.Add(movie); + var smart = new SmartCollection { Id = 30, Name = "Smart", Query = "tag:kids" }; + var multi = new MultiCollection + { + Id = 40, + Name = "Multi", + Collections = [collection], + SmartCollections = [smart] + }; + var rerun = new RerunCollection { Id = 50, Name = "Rerun", CollectionType = CollectionType.Collection }; + var playlist = new Playlist + { + Id = 60, + Name = "Playlist", + Items = [new PlaylistItem { CollectionType = CollectionType.Collection, CollectionId = 20 }] + }; + + context.Collections.Add(collection); + context.Movies.Add(movie); + context.SmartCollections.Add(smart); + context.MultiCollections.Add(multi); + context.RerunCollections.Add(rerun); + context.Playlists.Add(playlist); + await context.SaveChangesAsync(); + } + + private static MovieMetadata MakeMovieMetadata(string title, string poster) => + new() + { + Title = title, + SortTitle = title, + Artwork = [new Artwork { Path = poster, ArtworkKind = ArtworkKind.Poster }], + Genres = [], + Tags = [], + Studios = [], + Actors = [], + Guids = [], + Subtitles = [], + Directors = [], + Writers = [] + }; + + private static ShowMetadata MakeShowMetadata(string title, string poster) => + new() + { + Title = title, + SortTitle = title, + Artwork = [new Artwork { Path = poster, ArtworkKind = ArtworkKind.Poster }], + Genres = [], + Tags = [], + Studios = [], + Actors = [], + Guids = [], + Subtitles = [] + }; +} diff --git a/ErsatzTV.Tests/Controllers/LibraryBrowseControllerTests.cs b/ErsatzTV.Tests/Controllers/LibraryBrowseControllerTests.cs new file mode 100644 index 000000000..13011dabb --- /dev/null +++ b/ErsatzTV.Tests/Controllers/LibraryBrowseControllerTests.cs @@ -0,0 +1,92 @@ +using System.Reflection; +using ErsatzTV.Application.LibraryBrowse; +using ErsatzTV.Controllers.Api; +using ErsatzTV.Core.Api.LibraryBrowse; +using ErsatzTV.Core.Domain; +using MediatR; +using Microsoft.AspNetCore.Mvc; +using Microsoft.AspNetCore.Mvc.Routing; +using NSubstitute; +using NUnit.Framework; +using Shouldly; + +namespace ErsatzTV.Tests.Controllers; + +[TestFixture] +public class LibraryBrowseControllerTests +{ + private LibraryBrowseController _controller = null!; + private IMediator _mediator = null!; + + [SetUp] + public void SetUp() + { + _mediator = Substitute.For(); + _controller = new LibraryBrowseController(_mediator); + } + + [Test] + public void Controller_Should_Expose_Browse_Route_With_Stable_Operation_Name() + { + MethodInfo action = typeof(LibraryBrowseController).GetMethod(nameof(LibraryBrowseController.Browse)) + ?? throw new AssertionException($"Missing action {nameof(LibraryBrowseController.Browse)}"); + + var attribute = action.GetCustomAttributes().Single(); + attribute.Template.ShouldBe("/api/library/browse"); + attribute.Name.ShouldBe("BrowseLibrary"); + } + + [Test] + public async Task Browse_Should_Clamp_Paging_And_Send_Query() + { + _mediator.Send(Arg.Any(), Arg.Any()) + .Returns(new PagedLibraryBrowseItemsResponseModel(0, [])); + + await _controller.Browse( + "star", + 123, + LibraryBrowseMediaType.Movie, + -1, + 500, + CancellationToken.None); + + await _mediator.Received(1).Send( + Arg.Is(q => + q.Query == "star" && + q.LibraryId == 123 && + q.MediaType == LibraryBrowseMediaType.Movie && + q.PageNum == 0 && + q.PageSize == 100), + Arg.Any()); + } + + [Test] + public async Task Browse_Should_Return_Paged_Response() + { + var item = new LibraryBrowseItemResponseModel( + 10, + LibraryBrowseMediaType.Movie, + "Movie", + 3, + "Movies", + "/artwork/posters/movie.jpg", + TimeSpan.FromMinutes(90), + 1, + null, + CollectionType.Movie, + null, + null, + null, + null, + 10, + null); + _mediator.Send(Arg.Any(), Arg.Any()) + .Returns(new PagedLibraryBrowseItemsResponseModel(1, [item])); + + PagedLibraryBrowseItemsResponseModel result = await _controller.Browse( + cancellationToken: CancellationToken.None); + + result.TotalCount.ShouldBe(1); + result.Page.ShouldBe([item]); + } +} diff --git a/ErsatzTV/Controllers/Api/LibraryBrowseController.cs b/ErsatzTV/Controllers/Api/LibraryBrowseController.cs new file mode 100644 index 000000000..67c14903b --- /dev/null +++ b/ErsatzTV/Controllers/Api/LibraryBrowseController.cs @@ -0,0 +1,33 @@ +using ErsatzTV.Application.LibraryBrowse; +using ErsatzTV.Core.Api.LibraryBrowse; +using MediatR; +using Microsoft.AspNetCore.Http; +using Microsoft.AspNetCore.Mvc; + +namespace ErsatzTV.Controllers.Api; + +[ApiController] +public class LibraryBrowseController(IMediator mediator) : ControllerBase +{ + private const int MaxPageSize = 100; + + [HttpGet("/api/library/browse", Name = "BrowseLibrary")] + [Tags("Library")] + [EndpointSummary("Browse and search library items")] + [EndpointGroupName("general")] + [ProducesResponseType(typeof(PagedLibraryBrowseItemsResponseModel), StatusCodes.Status200OK)] + public async Task Browse( + [FromQuery] string query = "", + [FromQuery] int? libraryId = null, + [FromQuery] LibraryBrowseMediaType? mediaType = null, + [FromQuery] int pageNum = 0, + [FromQuery] int pageSize = 100, + CancellationToken cancellationToken = default) + { + int clampedPageNum = Math.Max(0, pageNum); + int clampedPageSize = Math.Clamp(pageSize, 1, MaxPageSize); + return await mediator.Send( + new GetLibraryBrowseItems(query, libraryId, mediaType, clampedPageNum, clampedPageSize), + cancellationToken); + } +} diff --git a/ErsatzTV/wwwroot/openapi/v1.json b/ErsatzTV/wwwroot/openapi/v1.json index e1a7159ea..d894ddc1d 100644 --- a/ErsatzTV/wwwroot/openapi/v1.json +++ b/ErsatzTV/wwwroot/openapi/v1.json @@ -1995,6 +1995,80 @@ } } }, + "/api/library/browse": { + "get": { + "tags": [ + "Library" + ], + "summary": "Browse and search library items", + "operationId": "BrowseLibrary", + "parameters": [ + { + "name": "query", + "in": "query", + "schema": { + "type": "string", + "default": "" + } + }, + { + "name": "libraryId", + "in": "query", + "schema": { + "type": "integer", + "format": "int32" + } + }, + { + "name": "mediaType", + "in": "query", + "schema": { + "$ref": "#/components/schemas/LibraryBrowseMediaType" + } + }, + { + "name": "pageNum", + "in": "query", + "schema": { + "type": "integer", + "format": "int32", + "default": 0 + } + }, + { + "name": "pageSize", + "in": "query", + "schema": { + "type": "integer", + "format": "int32", + "default": 100 + } + } + ], + "responses": { + "200": { + "description": "OK", + "content": { + "text/plain": { + "schema": { + "$ref": "#/components/schemas/PagedLibraryBrowseItemsResponseModel" + } + }, + "application/json": { + "schema": { + "$ref": "#/components/schemas/PagedLibraryBrowseItemsResponseModel" + } + }, + "text/json": { + "schema": { + "$ref": "#/components/schemas/PagedLibraryBrowseItemsResponseModel" + } + } + } + } + } + } + }, "/api/maintenance/gc": { "get": { "tags": [ @@ -5346,6 +5420,134 @@ "type": "string", "format": "binary" }, + "LibraryBrowseItemResponseModel": { + "required": [ + "id", + "mediaType", + "title", + "libraryId", + "libraryName", + "artwork", + "duration", + "itemCount", + "collectionKind", + "collectionType", + "collectionId", + "multiCollectionId", + "smartCollectionId", + "rerunCollectionId", + "mediaItemId", + "playlistId" + ], + "type": "object", + "properties": { + "id": { + "type": "integer", + "format": "int32" + }, + "mediaType": { + "$ref": "#/components/schemas/LibraryBrowseMediaType" + }, + "title": { + "type": "string" + }, + "libraryId": { + "type": [ + "null", + "integer" + ], + "format": "int32" + }, + "libraryName": { + "type": [ + "null", + "string" + ] + }, + "artwork": { + "type": "string" + }, + "duration": { + "pattern": "^-?(\\d+\\.)?\\d{2}:\\d{2}:\\d{2}(\\.\\d{1,7})?$", + "type": [ + "null", + "string" + ] + }, + "itemCount": { + "type": [ + "null", + "integer" + ], + "format": "int32" + }, + "collectionKind": { + "type": [ + "null", + "string" + ] + }, + "collectionType": { + "$ref": "#/components/schemas/CollectionType" + }, + "collectionId": { + "type": [ + "null", + "integer" + ], + "format": "int32" + }, + "multiCollectionId": { + "type": [ + "null", + "integer" + ], + "format": "int32" + }, + "smartCollectionId": { + "type": [ + "null", + "integer" + ], + "format": "int32" + }, + "rerunCollectionId": { + "type": [ + "null", + "integer" + ], + "format": "int32" + }, + "mediaItemId": { + "type": [ + "null", + "integer" + ], + "format": "int32" + }, + "playlistId": { + "type": [ + "null", + "integer" + ], + "format": "int32" + } + } + }, + "LibraryBrowseMediaType": { + "enum": [ + "Movie", + "TelevisionShow", + "TelevisionSeason", + "Artist", + "Collection", + "SmartCollection", + "MultiCollection", + "RerunCollection", + "Playlist" + ], + "type": "string" + }, "LibraryMediaKind": { "enum": [ "Movies", @@ -5646,6 +5848,25 @@ ], "type": "string" }, + "PagedLibraryBrowseItemsResponseModel": { + "required": [ + "totalCount", + "page" + ], + "type": "object", + "properties": { + "totalCount": { + "type": "integer", + "format": "int32" + }, + "page": { + "type": "array", + "items": { + "$ref": "#/components/schemas/LibraryBrowseItemResponseModel" + } + } + } + }, "PagedPlayoutItemsResponseModel": { "required": [ "totalCount", @@ -7215,6 +7436,9 @@ { "name": "Libraries" }, + { + "name": "Library" + }, { "name": "Maintenance" }, diff --git a/web/src/api/generated/v1.d.ts b/web/src/api/generated/v1.d.ts index af5bc052f..b1a00670b 100644 --- a/web/src/api/generated/v1.d.ts +++ b/web/src/api/generated/v1.d.ts @@ -292,6 +292,25 @@ export interface components { "lastAccess": string; }; "IFormFile": string; + "LibraryBrowseItemResponseModel": { + "id": number; + "mediaType": components["schemas"]["LibraryBrowseMediaType"]; + "title": string; + "libraryId": null | number; + "libraryName": null | string; + "artwork": string; + "duration": null | string; + "itemCount": null | number; + "collectionKind": null | string; + "collectionType": components["schemas"]["CollectionType"]; + "collectionId": null | number; + "multiCollectionId": null | number; + "smartCollectionId": null | number; + "rerunCollectionId": null | number; + "mediaItemId": null | number; + "playlistId": null | number; + }; + "LibraryBrowseMediaType": "Movie" | "TelevisionShow" | "TelevisionSeason" | "Artist" | "Collection" | "SmartCollection" | "MultiCollection" | "RerunCollection" | "Playlist"; "LibraryMediaKind": "Movies" | "Shows" | "MusicVideos" | "OtherVideos" | "Songs" | "Images" | "RemoteStreams"; "LibraryScanStatusResponseModel": { "libraryId": number; @@ -350,6 +369,10 @@ export interface components { "name": null | string; }; "NormalizeLoudnessMode": "Off" | "LoudNorm"; + "PagedLibraryBrowseItemsResponseModel": { + "totalCount": number; + "page": Array; + }; "PagedPlayoutItemsResponseModel": { "totalCount": number; "page": null | Array; -- 2.47.3 From 630119f382385040d77cd68b63b1ceb6fb88464b Mon Sep 17 00:00:00 2001 From: Timothy Date: Mon, 6 Jul 2026 07:45:39 +0200 Subject: [PATCH 2/2] fix(api): address library browse review findings refs #65 refs PR #130 --- .../Queries/GetLibraryBrowseItemsHandler.cs | 281 ++++++++++++- .../GetLibraryBrowseItemsHandlerTests.cs | 381 ++++++++++++++++++ .../Api/LibraryBrowseController.cs | 2 +- ErsatzTV/wwwroot/openapi/v1.json | 5 +- 4 files changed, 656 insertions(+), 13 deletions(-) diff --git a/ErsatzTV.Application/LibraryBrowse/Queries/GetLibraryBrowseItemsHandler.cs b/ErsatzTV.Application/LibraryBrowse/Queries/GetLibraryBrowseItemsHandler.cs index 5d759a7bd..96854f113 100644 --- a/ErsatzTV.Application/LibraryBrowse/Queries/GetLibraryBrowseItemsHandler.cs +++ b/ErsatzTV.Application/LibraryBrowse/Queries/GetLibraryBrowseItemsHandler.cs @@ -33,6 +33,8 @@ public class GetLibraryBrowseItemsHandler( 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 collectionItems = collectionTake > 0 @@ -162,7 +164,10 @@ public class GetLibraryBrowseItemsHandler( .Include(mm => mm.Movie) .ThenInclude(m => m.MediaVersions) .ToListAsync(cancellationToken) - .Map(list => list.Map(mm => new LibraryBrowseItemResponseModel( + .Map(list => list + .GroupBy(mm => mm.MovieId) + .Select(g => g.OrderBy(mm => mm.Id).First()) + .Map(mm => new LibraryBrowseItemResponseModel( mm.MovieId, LibraryBrowseMediaType.Movie, mm.Title ?? string.Empty, @@ -206,7 +211,10 @@ public class GetLibraryBrowseItemsHandler( .ThenInclude(s => s.LibraryPath) .ThenInclude(lp => lp.Library) .ToListAsync(cancellationToken) - .Map(list => list.Map(sm => new LibraryBrowseItemResponseModel( + .Map(list => list + .GroupBy(sm => sm.ShowId) + .Select(g => g.OrderBy(sm => sm.Id).First()) + .Map(sm => new LibraryBrowseItemResponseModel( sm.ShowId, LibraryBrowseMediaType.TelevisionShow, sm.Title ?? string.Empty, @@ -253,7 +261,10 @@ public class GetLibraryBrowseItemsHandler( .ThenInclude(s => s.LibraryPath) .ThenInclude(lp => lp.Library) .ToListAsync(cancellationToken) - .Map(list => list.Map(sm => new LibraryBrowseItemResponseModel( + .Map(list => list + .GroupBy(sm => sm.SeasonId) + .Select(g => g.OrderBy(sm => sm.Id).First()) + .Map(sm => new LibraryBrowseItemResponseModel( sm.SeasonId, LibraryBrowseMediaType.TelevisionSeason, SeasonTitle(sm), @@ -297,7 +308,10 @@ public class GetLibraryBrowseItemsHandler( .ThenInclude(a => a.LibraryPath) .ThenInclude(lp => lp.Library) .ToListAsync(cancellationToken) - .Map(list => list.Map(am => new LibraryBrowseItemResponseModel( + .Map(list => list + .GroupBy(am => am.ArtistId) + .Select(g => g.OrderBy(am => am.Id).First()) + .Map(am => new LibraryBrowseItemResponseModel( am.ArtistId, LibraryBrowseMediaType.Artist, am.Title ?? string.Empty, @@ -385,6 +399,11 @@ public class GetLibraryBrowseItemsHandler( .GroupBy(ci => ci.CollectionId) .Select(g => new { CollectionId = g.Key, Count = g.Count() }) .ToDictionaryAsync(g => g.CollectionId, g => g.Count, cancellationToken); + Dictionary durations = await GetManualCollectionDurations( + dbContext, + collectionIds, + cancellationToken); + Dictionary artwork = await GetManualCollectionArtwork(dbContext, collectionIds, cancellationToken); results.AddRange(collections.Map(c => new LibraryBrowseItemResponseModel( c.Id, @@ -392,8 +411,8 @@ public class GetLibraryBrowseItemsHandler( c.Name, null, null, - string.Empty, - 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, @@ -552,6 +571,7 @@ public class GetLibraryBrowseItemsHandler( null, null, "Rerun", + // RerunFirstRun addresses the first-run side; the SPA can substitute RerunRerun for rerun schedule items. CollectionType.RerunFirstRun, null, null, @@ -633,7 +653,7 @@ public class GetLibraryBrowseItemsHandler( return query; } - return query.Where(c => EF.Functions.Like(EF.Property(c, "Name"), $"%{searchQuery}%")); + return query.Where(c => EF.Functions.Like(EF.Property(c, "Name"), $"%{EscapeLike(searchQuery)}%", "\\")); } private static bool ShouldInclude(LibraryBrowseMediaType? requestType, LibraryBrowseMediaType itemType) => @@ -641,10 +661,247 @@ public class GetLibraryBrowseItemsHandler( private static TimeSpan? BestDuration(IEnumerable versions) { - TimeSpan duration = versions.Select(v => v.Duration).FirstOrDefault(d => d > TimeSpan.Zero); + TimeSpan duration = versions + .Select(v => v.Duration) + .Where(d => d > TimeSpan.Zero) + .DefaultIfEmpty() + .Max(); return duration > TimeSpan.Zero ? duration : null; } + private static async Task> GetManualCollectionDurations( + TvContext dbContext, + List collectionIds, + CancellationToken cancellationToken) + { + List items = await GetCollectionMediaItems(dbContext, collectionIds, cancellationToken); + List mediaItemIds = items.Map(i => i.MediaItemId).Distinct().ToList(); + Dictionary mediaItemDurations = []; + + foreach (Movie movie in await dbContext.Movies + .AsNoTracking() + .Where(m => mediaItemIds.Contains(m.Id)) + .Include(m => m.MediaVersions) + .ToListAsync(cancellationToken)) + { + TimeSpan? duration = 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 = 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 = 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 = 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 = 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 = 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 = 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> GetManualCollectionArtwork( + TvContext dbContext, + List collectionIds, + CancellationToken cancellationToken) + { + List items = await GetCollectionMediaItems(dbContext, collectionIds, cancellationToken); + List mediaItemIds = items.Map(i => i.MediaItemId).Distinct().ToList(); + Dictionary 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 = 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 = 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 = 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 = 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 = 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 = 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 = 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> GetCollectionMediaItems( + TvContext dbContext, + List 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 SeasonTitle(SeasonMetadata metadata) { string showTitle = metadata.Season.Show.ShowMetadata.HeadOrNone() @@ -685,4 +942,12 @@ public class GetLibraryBrowseItemsHandler( return artwork; } + + 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); } diff --git a/ErsatzTV.Tests/Application/LibraryBrowse/GetLibraryBrowseItemsHandlerTests.cs b/ErsatzTV.Tests/Application/LibraryBrowse/GetLibraryBrowseItemsHandlerTests.cs index 9bfaab26d..c34ad3890 100644 --- a/ErsatzTV.Tests/Application/LibraryBrowse/GetLibraryBrowseItemsHandlerTests.cs +++ b/ErsatzTV.Tests/Application/LibraryBrowse/GetLibraryBrowseItemsHandlerTests.cs @@ -137,6 +137,161 @@ public class GetLibraryBrowseItemsHandlerTests i.PlaylistId == 60); } + [Test] + public async Task Handle_Should_Page_Across_Media_Manual_Collections_And_Smart_Collections() + { + await SeedMediaAndCollectionPagingGraph(); + _searchIndex.Search( + Arg.Any(), + Arg.Any(), + Arg.Is(offset => offset == 0), + Arg.Any(), + Arg.Any>(), + Arg.Any()) + .Returns(new SearchResult( + [ + new SearchItem(LuceneSearchIndex.MovieType, 101), + new SearchItem(LuceneSearchIndex.MovieType, 102) + ], + 2)); + _searchIndex.Search( + Arg.Any(), + Arg.Any(), + Arg.Is(offset => offset > 0), + Arg.Any(), + Arg.Any>(), + Arg.Any()) + .Returns(new SearchResult([], 2)); + var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory); + + PagedLibraryBrowseItemsResponseModel page0 = await handler.Handle( + new GetLibraryBrowseItems("", null, null, 0, 3), + CancellationToken.None); + PagedLibraryBrowseItemsResponseModel page1 = await handler.Handle( + new GetLibraryBrowseItems("", null, null, 1, 3), + CancellationToken.None); + PagedLibraryBrowseItemsResponseModel page2 = await handler.Handle( + new GetLibraryBrowseItems("", null, null, 2, 3), + CancellationToken.None); + + page0.TotalCount.ShouldBe(7); + page0.Page.Select(i => i.Title).ShouldBe(["Movie One", "Movie Two", "Manual A"]); + page1.TotalCount.ShouldBe(7); + page1.Page.Select(i => i.Title).ShouldBe(["Manual B", "Manual C", "Smart A"]); + page2.TotalCount.ShouldBe(7); + page2.Page.Select(i => i.Title).ShouldBe(["Smart B"]); + } + + [Test] + public async Task Handle_Should_Hydrate_Manual_Collection_Artwork_And_Total_Duration() + { + await SeedManualCollectionMetadataGraph(); + _searchIndex.Search( + Arg.Any(), + Arg.Any(), + Arg.Any(), + Arg.Any(), + Arg.Any>(), + Arg.Any()) + .Returns(new SearchResult([], 0)); + var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory); + + PagedLibraryBrowseItemsResponseModel result = await handler.Handle( + new GetLibraryBrowseItems("", null, LibraryBrowseMediaType.Collection, 0, 10), + CancellationToken.None); + + result.TotalCount.ShouldBe(1); + result.Page.Count.ShouldBe(1); + result.Page[0].Title.ShouldBe("Manual Metadata"); + result.Page[0].Artwork.ShouldBe("first-poster.jpg"); + result.Page[0].Duration.ShouldBe(TimeSpan.FromMinutes(75)); + result.Page[0].ItemCount.ShouldBe(2); + } + + [Test] + public async Task Handle_Should_Hydrate_Seasons_With_Composed_Titles_And_Episode_Counts() + { + await SeedSeasonGraph(); + _searchIndex.Search( + Arg.Any(), + Arg.Any(), + Arg.Any(), + Arg.Any(), + Arg.Any>(), + Arg.Any()) + .Returns(new SearchResult( + [ + new SearchItem(LuceneSearchIndex.SeasonType, 301), + new SearchItem(LuceneSearchIndex.SeasonType, 302) + ], + 2)); + var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory); + + PagedLibraryBrowseItemsResponseModel result = await handler.Handle( + new GetLibraryBrowseItems("", null, LibraryBrowseMediaType.TelevisionSeason, 0, 10), + CancellationToken.None); + + result.TotalCount.ShouldBe(2); + result.Page[0].Title.ShouldBe("Season Show - Season 2"); + result.Page[0].ItemCount.ShouldBe(2); + result.Page[0].CollectionType.ShouldBe(CollectionType.TelevisionSeason); + result.Page[0].MediaItemId.ShouldBe(301); + result.Page[1].Title.ShouldBe("Season Show - Specials"); + result.Page[1].ItemCount.ShouldBe(1); + result.Page[1].MediaItemId.ShouldBe(302); + } + + [Test] + public async Task Handle_Should_Hydrate_Artists_With_Music_Video_Counts() + { + await SeedArtistGraph(); + _searchIndex.Search( + Arg.Any(), + Arg.Any(), + Arg.Any(), + Arg.Any(), + Arg.Any>(), + Arg.Any()) + .Returns(new SearchResult([new SearchItem(LuceneSearchIndex.ArtistType, 401)], 1)); + var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory); + + PagedLibraryBrowseItemsResponseModel result = await handler.Handle( + new GetLibraryBrowseItems("", null, LibraryBrowseMediaType.Artist, 0, 10), + CancellationToken.None); + + result.TotalCount.ShouldBe(1); + result.Page[0].Title.ShouldBe("Counted Artist"); + result.Page[0].ItemCount.ShouldBe(2); + result.Page[0].Artwork.ShouldBe("artist-thumb.jpg"); + result.Page[0].CollectionType.ShouldBe(CollectionType.Artist); + result.Page[0].MediaItemId.ShouldBe(401); + } + + [Test] + public async Task Handle_Should_Apply_Library_Filter_To_Manual_Collections_Only() + { + await SeedLibraryFilteredCollectionsGraph(); + _searchIndex.Search( + Arg.Any(), + Arg.Any(), + Arg.Any(), + Arg.Any(), + Arg.Any>(), + Arg.Any()) + .Returns(new SearchResult([], 0)); + var handler = new GetLibraryBrowseItemsHandler(_searchIndex, _db.Factory); + + PagedLibraryBrowseItemsResponseModel result = await handler.Handle( + new GetLibraryBrowseItems("", 501, null, 0, 10), + CancellationToken.None); + + result.TotalCount.ShouldBe(1); + result.Page.Count.ShouldBe(1); + result.Page[0].Title.ShouldBe("Included Manual"); + result.Page[0].MediaType.ShouldBe(LibraryBrowseMediaType.Collection); + result.Page[0].CollectionId.ShouldBe(510); + } + private async Task SeedLibraryGraph() { await using TvContext context = _db.CreateContext(); @@ -252,6 +407,202 @@ public class GetLibraryBrowseItemsHandlerTests await context.SaveChangesAsync(); } + private async Task SeedMediaAndCollectionPagingGraph() + { + await using TvContext context = _db.CreateContext(); + (LocalLibrary library, LibraryPath path) = MakeLibrary(100, "Paging Library"); + + var movie1 = MakeMovie(101, path, "Movie One", "movie-one.jpg", TimeSpan.FromMinutes(10)); + var movie2 = MakeMovie(102, path, "Movie Two", "movie-two.jpg", TimeSpan.FromMinutes(20)); + var manualA = MakeCollection(201, "Manual A"); + var manualB = MakeCollection(202, "Manual B"); + var manualC = MakeCollection(203, "Manual C"); + + context.LocalLibraries.Add(library); + context.Movies.AddRange(movie1, movie2); + context.Collections.AddRange(manualA, manualB, manualC); + context.SmartCollections.AddRange( + new SmartCollection { Id = 301, Name = "Smart A", Query = "tag:a", MultiCollections = [], MultiCollectionSmartItems = [] }, + new SmartCollection { Id = 302, Name = "Smart B", Query = "tag:b", MultiCollections = [], MultiCollectionSmartItems = [] }); + await context.SaveChangesAsync(); + } + + private async Task SeedManualCollectionMetadataGraph() + { + await using TvContext context = _db.CreateContext(); + (LocalLibrary library, LibraryPath path) = MakeLibrary(200, "Manual Metadata Library"); + var collection = MakeCollection(210, "Manual Metadata"); + var first = MakeMovie(211, path, "First", "first-poster.jpg", TimeSpan.FromMinutes(30)); + var second = MakeMovie(212, path, "Second", "second-poster.jpg", TimeSpan.FromMinutes(45)); + collection.MediaItems.AddRange([first, second]); + + context.LocalLibraries.Add(library); + context.Collections.Add(collection); + context.Movies.AddRange(first, second); + await context.SaveChangesAsync(); + } + + private async Task SeedSeasonGraph() + { + await using TvContext context = _db.CreateContext(); + (LocalLibrary library, LibraryPath path) = MakeLibrary(300, "Season Library"); + var show = new Show + { + Id = 300, + LibraryPath = path, + Collections = [], + CollectionItems = [], + TraktListItems = [], + Seasons = [], + ShowMetadata = [MakeShowMetadata("Season Show", "show.jpg")] + }; + var season = MakeSeason(301, path, show, 2); + var specials = MakeSeason(302, path, show, 0); + season.Episodes.AddRange([ + MakeEpisode(311, path, season), + MakeEpisode(312, path, season) + ]); + specials.Episodes.Add(MakeEpisode(313, path, specials)); + show.Seasons.AddRange([season, specials]); + path.MediaItems.AddRange([show, season, specials, .. season.Episodes, .. specials.Episodes]); + + context.LocalLibraries.Add(library); + context.Shows.Add(show); + context.Seasons.AddRange(season, specials); + await context.SaveChangesAsync(); + } + + private async Task SeedArtistGraph() + { + await using TvContext context = _db.CreateContext(); + (LocalLibrary library, LibraryPath path) = MakeLibrary(400, "Artist Library"); + var artist = new Artist + { + Id = 401, + LibraryPath = path, + Collections = [], + CollectionItems = [], + TraktListItems = [], + MusicVideos = [], + ArtistMetadata = [MakeArtistMetadata("Counted Artist", "artist-thumb.jpg")] + }; + var musicVideo1 = MakeMusicVideo(411, path, artist); + var musicVideo2 = MakeMusicVideo(412, path, artist); + artist.MusicVideos.AddRange([musicVideo1, musicVideo2]); + path.MediaItems.AddRange([artist, musicVideo1, musicVideo2]); + + context.LocalLibraries.Add(library); + context.Artists.Add(artist); + context.MusicVideos.AddRange(musicVideo1, musicVideo2); + await context.SaveChangesAsync(); + } + + private async Task SeedLibraryFilteredCollectionsGraph() + { + await using TvContext context = _db.CreateContext(); + (LocalLibrary includedLibrary, LibraryPath includedPath) = MakeLibrary(501, "Included Library"); + (LocalLibrary excludedLibrary, LibraryPath excludedPath) = MakeLibrary(502, "Excluded Library"); + var includedCollection = MakeCollection(510, "Included Manual"); + var excludedCollection = MakeCollection(511, "Excluded Manual"); + var includedMovie = MakeMovie(520, includedPath, "Included Movie", "included.jpg", TimeSpan.FromMinutes(5)); + var excludedMovie = MakeMovie(521, excludedPath, "Excluded Movie", "excluded.jpg", TimeSpan.FromMinutes(5)); + includedCollection.MediaItems.Add(includedMovie); + excludedCollection.MediaItems.Add(excludedMovie); + + context.LocalLibraries.AddRange(includedLibrary, excludedLibrary); + context.Movies.AddRange(includedMovie, excludedMovie); + context.Collections.AddRange(includedCollection, excludedCollection); + context.SmartCollections.Add(new SmartCollection { Id = 530, Name = "Smart", Query = "tag", MultiCollections = [], MultiCollectionSmartItems = [] }); + context.MultiCollections.Add(new MultiCollection { Id = 540, Name = "Multi", Collections = [], SmartCollections = [], MultiCollectionItems = [], MultiCollectionSmartItems = [] }); + context.RerunCollections.Add(new RerunCollection { Id = 550, Name = "Rerun", CollectionType = CollectionType.Collection }); + context.Playlists.Add(new Playlist { Id = 560, Name = "Playlist", Items = [] }); + await context.SaveChangesAsync(); + } + + private static (LocalLibrary Library, LibraryPath Path) MakeLibrary(int id, string name) + { + var library = new LocalLibrary + { + Id = id, + Name = name, + MediaKind = LibraryMediaKind.Movies, + Paths = [] + }; + var path = new LibraryPath + { + Id = id, + Path = $"/media/{id}", + Library = library, + LibraryFolders = [], + MediaItems = [] + }; + library.Paths.Add(path); + return (library, path); + } + + private static Collection MakeCollection(int id, string name) => + new() + { + Id = id, + Name = name, + MediaItems = [], + CollectionItems = [], + MultiCollections = [], + MultiCollectionItems = [] + }; + + private static Movie MakeMovie(int id, LibraryPath path, string title, string poster, TimeSpan duration) => + new() + { + Id = id, + LibraryPath = path, + Collections = [], + CollectionItems = [], + TraktListItems = [], + MovieMetadata = [MakeMovieMetadata(title, poster)], + MediaVersions = [new MediaVersion { Duration = duration }] + }; + + private static Season MakeSeason(int id, LibraryPath path, Show show, int seasonNumber) => + new() + { + Id = id, + LibraryPath = path, + Show = show, + SeasonNumber = seasonNumber, + Collections = [], + CollectionItems = [], + TraktListItems = [], + Episodes = [], + SeasonMetadata = [MakeSeasonMetadata()] + }; + + private static Episode MakeEpisode(int id, LibraryPath path, Season season) => + new() + { + Id = id, + LibraryPath = path, + Season = season, + Collections = [], + CollectionItems = [], + TraktListItems = [], + EpisodeMetadata = [], + MediaVersions = [] + }; + + private static MusicVideo MakeMusicVideo(int id, LibraryPath path, Artist artist) => + new() + { + Id = id, + LibraryPath = path, + Artist = artist, + Collections = [], + CollectionItems = [], + TraktListItems = [], + MusicVideoMetadata = [], + MediaVersions = [] + }; + private static MovieMetadata MakeMovieMetadata(string title, string poster) => new() { @@ -281,4 +632,34 @@ public class GetLibraryBrowseItemsHandlerTests Guids = [], Subtitles = [] }; + + private static SeasonMetadata MakeSeasonMetadata() => + new() + { + Title = string.Empty, + SortTitle = string.Empty, + Artwork = [], + Genres = [], + Tags = [], + Studios = [], + Actors = [], + Guids = [], + Subtitles = [] + }; + + private static ArtistMetadata MakeArtistMetadata(string title, string thumbnail) => + new() + { + Title = title, + SortTitle = title, + Artwork = [new Artwork { Path = thumbnail, ArtworkKind = ArtworkKind.Thumbnail }], + Genres = [], + Tags = [], + Studios = [], + Actors = [], + Guids = [], + Subtitles = [], + Styles = [], + Moods = [] + }; } diff --git a/ErsatzTV/Controllers/Api/LibraryBrowseController.cs b/ErsatzTV/Controllers/Api/LibraryBrowseController.cs index 67c14903b..669c305aa 100644 --- a/ErsatzTV/Controllers/Api/LibraryBrowseController.cs +++ b/ErsatzTV/Controllers/Api/LibraryBrowseController.cs @@ -12,7 +12,7 @@ public class LibraryBrowseController(IMediator mediator) : ControllerBase private const int MaxPageSize = 100; [HttpGet("/api/library/browse", Name = "BrowseLibrary")] - [Tags("Library")] + [Tags("Libraries")] [EndpointSummary("Browse and search library items")] [EndpointGroupName("general")] [ProducesResponseType(typeof(PagedLibraryBrowseItemsResponseModel), StatusCodes.Status200OK)] diff --git a/ErsatzTV/wwwroot/openapi/v1.json b/ErsatzTV/wwwroot/openapi/v1.json index d894ddc1d..3512b4492 100644 --- a/ErsatzTV/wwwroot/openapi/v1.json +++ b/ErsatzTV/wwwroot/openapi/v1.json @@ -1998,7 +1998,7 @@ "/api/library/browse": { "get": { "tags": [ - "Library" + "Libraries" ], "summary": "Browse and search library items", "operationId": "BrowseLibrary", @@ -7436,9 +7436,6 @@ { "name": "Libraries" }, - { - "name": "Library" - }, { "name": "Maintenance" }, -- 2.47.3