feat(api): library browse + search endpoints (#65) #130
@@ -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<PagedLibraryBrowseItemsResponseModel>;
|
||||
@@ -0,0 +1,953 @@
|
||||
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<TvContext> dbContextFactory)
|
||||
: IRequestHandler<GetLibraryBrowseItems, PagedLibraryBrowseItemsResponseModel>
|
||||
{
|
||||
private const string LibraryIdField = "library_id";
|
||||
|
||||
public async Task<PagedLibraryBrowseItemsResponseModel> 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<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],
|
||||
null =>
|
||||
[
|
||||
LuceneSearchIndex.MovieType,
|
||||
LuceneSearchIndex.ShowType,
|
||||
LuceneSearchIndex.SeasonType,
|
||||
LuceneSearchIndex.ArtistType
|
||||
],
|
||||
_ => []
|
||||
};
|
||||
|
||||
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();
|
||||
|
||||
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<List<LibraryBrowseItemResponseModel>> GetMovies(
|
||||
TvContext dbContext,
|
||||
List<int> 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
|
||||
.GroupBy(mm => mm.MovieId)
|
||||
.Select(g => g.OrderBy(mm => mm.Id).First())
|
||||
.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<List<LibraryBrowseItemResponseModel>> GetShows(
|
||||
TvContext dbContext,
|
||||
List<int> ids,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
if (ids.Count == 0)
|
||||
{
|
||||
return [];
|
||||
}
|
||||
|
||||
Dictionary<int, int> 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
|
||||
.GroupBy(sm => sm.ShowId)
|
||||
.Select(g => g.OrderBy(sm => sm.Id).First())
|
||||
.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<List<LibraryBrowseItemResponseModel>> GetSeasons(
|
||||
TvContext dbContext,
|
||||
List<int> ids,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
if (ids.Count == 0)
|
||||
{
|
||||
return [];
|
||||
}
|
||||
|
||||
Dictionary<int, int> 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
|
||||
.GroupBy(sm => sm.SeasonId)
|
||||
.Select(g => g.OrderBy(sm => sm.Id).First())
|
||||
.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<List<LibraryBrowseItemResponseModel>> GetArtists(
|
||||
TvContext dbContext,
|
||||
List<int> ids,
|
||||
CancellationToken cancellationToken)
|
||||
{
|
||||
if (ids.Count == 0)
|
||||
{
|
||||
return [];
|
||||
}
|
||||
|
||||
Dictionary<int, int> 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
|
||||
.GroupBy(am => am.ArtistId)
|
||||
.Select(g => g.OrderBy(am => am.Id).First())
|
||||
.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<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 TimeSpan? BestDuration(IEnumerable<MediaVersion> versions)
|
||||
{
|
||||
TimeSpan duration = versions
|
||||
.Select(v => v.Duration)
|
||||
.Where(d => d > TimeSpan.Zero)
|
||||
.DefaultIfEmpty()
|
||||
.Max();
|
||||
return duration > TimeSpan.Zero ? duration : null;
|
||||
}
|
||||
|
||||
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 = 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<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 = 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<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 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;
|
||||
}
|
||||
|
||||
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);
|
||||
}
|
||||
@@ -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);
|
||||
@@ -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
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
#nullable enable
|
||||
namespace ErsatzTV.Core.Api.LibraryBrowse;
|
||||
|
||||
public record PagedLibraryBrowseItemsResponseModel(
|
||||
int TotalCount,
|
||||
List<LibraryBrowseItemResponseModel> Page);
|
||||
@@ -0,0 +1,665 @@
|
||||
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<ISearchIndex>();
|
||||
}
|
||||
|
||||
[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<string>(),
|
||||
Arg.Any<string>(),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<List<string>>(),
|
||||
Arg.Any<CancellationToken>())
|
||||
.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<string>(q => q.Contains("type:movie") && q.Contains("library_id:5") && q.Contains("star")),
|
||||
string.Empty,
|
||||
50,
|
||||
25,
|
||||
Arg.Is<List<string>>(fields => fields.SequenceEqual(new[] { LuceneSearchIndex.TitleAndYearSearchField })),
|
||||
Arg.Any<CancellationToken>());
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Handle_Should_Hydrate_Media_Items_In_Search_Order_With_Artwork_Duration_And_Counts()
|
||||
{
|
||||
await SeedLibraryGraph();
|
||||
_searchIndex.Search(
|
||||
Arg.Any<string>(),
|
||||
Arg.Any<string>(),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<List<string>>(),
|
||||
Arg.Any<CancellationToken>())
|
||||
.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<string>(),
|
||||
Arg.Any<string>(),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<List<string>>(),
|
||||
Arg.Any<CancellationToken>())
|
||||
.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);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public async Task Handle_Should_Page_Across_Media_Manual_Collections_And_Smart_Collections()
|
||||
{
|
||||
await SeedMediaAndCollectionPagingGraph();
|
||||
_searchIndex.Search(
|
||||
Arg.Any<string>(),
|
||||
Arg.Any<string>(),
|
||||
Arg.Is<int>(offset => offset == 0),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<List<string>>(),
|
||||
Arg.Any<CancellationToken>())
|
||||
.Returns(new SearchResult(
|
||||
[
|
||||
new SearchItem(LuceneSearchIndex.MovieType, 101),
|
||||
new SearchItem(LuceneSearchIndex.MovieType, 102)
|
||||
],
|
||||
2));
|
||||
_searchIndex.Search(
|
||||
Arg.Any<string>(),
|
||||
Arg.Any<string>(),
|
||||
Arg.Is<int>(offset => offset > 0),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<List<string>>(),
|
||||
Arg.Any<CancellationToken>())
|
||||
.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<string>(),
|
||||
Arg.Any<string>(),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<List<string>>(),
|
||||
Arg.Any<CancellationToken>())
|
||||
.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<string>(),
|
||||
Arg.Any<string>(),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<List<string>>(),
|
||||
Arg.Any<CancellationToken>())
|
||||
.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<string>(),
|
||||
Arg.Any<string>(),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<List<string>>(),
|
||||
Arg.Any<CancellationToken>())
|
||||
.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<string>(),
|
||||
Arg.Any<string>(),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<int>(),
|
||||
Arg.Any<List<string>>(),
|
||||
Arg.Any<CancellationToken>())
|
||||
.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();
|
||||
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 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()
|
||||
{
|
||||
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 = []
|
||||
};
|
||||
|
||||
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 = []
|
||||
};
|
||||
}
|
||||
@@ -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<IMediator>();
|
||||
_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<HttpGetAttribute>().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<GetLibraryBrowseItems>(), Arg.Any<CancellationToken>())
|
||||
.Returns(new PagedLibraryBrowseItemsResponseModel(0, []));
|
||||
|
||||
await _controller.Browse(
|
||||
"star",
|
||||
123,
|
||||
LibraryBrowseMediaType.Movie,
|
||||
-1,
|
||||
500,
|
||||
CancellationToken.None);
|
||||
|
||||
await _mediator.Received(1).Send(
|
||||
Arg.Is<GetLibraryBrowseItems>(q =>
|
||||
q.Query == "star" &&
|
||||
q.LibraryId == 123 &&
|
||||
q.MediaType == LibraryBrowseMediaType.Movie &&
|
||||
q.PageNum == 0 &&
|
||||
q.PageSize == 100),
|
||||
Arg.Any<CancellationToken>());
|
||||
}
|
||||
|
||||
[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<GetLibraryBrowseItems>(), Arg.Any<CancellationToken>())
|
||||
.Returns(new PagedLibraryBrowseItemsResponseModel(1, [item]));
|
||||
|
||||
PagedLibraryBrowseItemsResponseModel result = await _controller.Browse(
|
||||
cancellationToken: CancellationToken.None);
|
||||
|
||||
result.TotalCount.ShouldBe(1);
|
||||
result.Page.ShouldBe([item]);
|
||||
}
|
||||
}
|
||||
@@ -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("Libraries")]
|
||||
[EndpointSummary("Browse and search library items")]
|
||||
[EndpointGroupName("general")]
|
||||
[ProducesResponseType(typeof(PagedLibraryBrowseItemsResponseModel), StatusCodes.Status200OK)]
|
||||
public async Task<PagedLibraryBrowseItemsResponseModel> 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);
|
||||
}
|
||||
}
|
||||
@@ -1995,6 +1995,80 @@
|
||||
}
|
||||
}
|
||||
},
|
||||
"/api/library/browse": {
|
||||
"get": {
|
||||
"tags": [
|
||||
"Libraries"
|
||||
],
|
||||
"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",
|
||||
|
||||
Vendored
+23
@@ -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<components["schemas"]["LibraryBrowseItemResponseModel"]>;
|
||||
};
|
||||
"PagedPlayoutItemsResponseModel": {
|
||||
"totalCount": number;
|
||||
"page": null | Array<components["schemas"]["PlayoutItemResponseModel"]>;
|
||||
|
||||
Reference in New Issue
Block a user