jellyfin-server/MediaBrowser.Api/UserLibrary/ItemsService.cs

379 lines
14 KiB
C#
Raw Normal View History

using MediaBrowser.Controller.Dto;
using MediaBrowser.Controller.Entities;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Controller.Library;
2013-04-14 00:17:25 +00:00
using MediaBrowser.Controller.Localization;
2014-07-02 18:34:08 +00:00
using MediaBrowser.Controller.Net;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Model.Entities;
2013-03-10 05:36:39 +00:00
using MediaBrowser.Model.Querying;
2013-12-07 15:52:38 +00:00
using ServiceStack;
2013-02-21 01:33:05 +00:00
using System;
using System.Collections.Generic;
2013-12-28 23:09:24 +00:00
using System.Globalization;
2013-02-21 01:33:05 +00:00
using System.Linq;
2014-10-06 23:58:46 +00:00
using System.Threading.Tasks;
2013-02-21 01:33:05 +00:00
namespace MediaBrowser.Api.UserLibrary
{
/// <summary>
/// Class GetItems
/// </summary>
2014-03-28 19:58:18 +00:00
[Route("/Items", "GET", Summary = "Gets items based on a query.")]
[Route("/Users/{UserId}/Items", "GET", Summary = "Gets items based on a query.")]
2013-03-11 05:06:55 +00:00
public class GetItems : BaseItemsRequest, IReturn<ItemsResult>
2013-02-21 01:33:05 +00:00
{
}
/// <summary>
/// Class ItemsService
/// </summary>
2014-07-02 18:34:08 +00:00
[Authenticated]
2013-03-16 05:52:33 +00:00
public class ItemsService : BaseApiService
2013-02-21 01:33:05 +00:00
{
/// <summary>
/// The _user manager
/// </summary>
private readonly IUserManager _userManager;
/// <summary>
/// The _library manager
/// </summary>
private readonly ILibraryManager _libraryManager;
private readonly ILocalizationManager _localization;
2013-03-09 05:15:51 +00:00
2013-09-04 17:02:19 +00:00
private readonly IDtoService _dtoService;
/// <summary>
/// Initializes a new instance of the <see cref="ItemsService" /> class.
/// </summary>
/// <param name="userManager">The user manager.</param>
2013-03-28 22:00:58 +00:00
/// <param name="libraryManager">The library manager.</param>
2014-04-22 17:25:54 +00:00
/// <param name="localization">The localization.</param>
/// <param name="dtoService">The dto service.</param>
2016-06-25 00:29:39 +00:00
public ItemsService(IUserManager userManager, ILibraryManager libraryManager, ILocalizationManager localization, IDtoService dtoService)
{
2016-06-26 20:35:03 +00:00
if (userManager == null)
{
throw new ArgumentNullException("userManager");
}
if (libraryManager == null)
{
throw new ArgumentNullException("libraryManager");
}
if (localization == null)
{
throw new ArgumentNullException("localization");
}
if (dtoService == null)
{
throw new ArgumentNullException("dtoService");
}
_userManager = userManager;
_libraryManager = libraryManager;
2013-06-13 18:17:59 +00:00
_localization = localization;
2013-09-04 17:02:19 +00:00
_dtoService = dtoService;
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Gets the specified request.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>System.Object.</returns>
2014-10-06 23:58:46 +00:00
public async Task<object> Get(GetItems request)
2013-02-21 01:33:05 +00:00
{
2016-06-26 20:35:03 +00:00
if (request == null)
{
throw new ArgumentNullException("request");
}
2014-10-06 23:58:46 +00:00
var result = await GetItems(request).ConfigureAwait(false);
2013-02-21 01:33:05 +00:00
return ToOptimizedSerializedResultUsingCache(result);
2013-02-21 01:33:05 +00:00
}
/// <summary>
/// Gets the items.
/// </summary>
/// <param name="request">The request.</param>
/// <returns>Task{ItemsResult}.</returns>
2014-10-06 23:58:46 +00:00
private async Task<ItemsResult> GetItems(GetItems request)
2013-02-21 01:33:05 +00:00
{
2015-05-29 23:51:33 +00:00
var user = !string.IsNullOrWhiteSpace(request.UserId) ? _userManager.GetUserById(request.UserId) : null;
2016-06-26 20:35:03 +00:00
2016-07-15 19:54:34 +00:00
var result = await GetQueryResult(request, user).ConfigureAwait(false);
2013-02-21 01:33:05 +00:00
2016-06-26 20:35:03 +00:00
if (result == null)
{
throw new InvalidOperationException("GetItemsToSerialize returned null");
}
2016-06-26 20:38:50 +00:00
if (result.Items == null)
{
throw new InvalidOperationException("GetItemsToSerialize result.Items returned null");
}
2015-01-24 19:03:55 +00:00
var dtoOptions = GetDtoOptions(request);
2013-04-05 15:58:06 +00:00
2016-06-26 20:35:03 +00:00
var dtoList = await _dtoService.GetBaseItemDtos(result.Items, dtoOptions, user).ConfigureAwait(false);
if (dtoList == null)
{
throw new InvalidOperationException("GetBaseItemDtos returned null");
}
2013-02-21 01:33:05 +00:00
return new ItemsResult
{
2016-03-20 06:46:51 +00:00
TotalRecordCount = result.TotalRecordCount,
2016-06-26 20:35:03 +00:00
Items = dtoList.ToArray()
2013-02-21 01:33:05 +00:00
};
}
/// <summary>
/// Gets the items to serialize.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="user">The user.</param>
/// <returns>IEnumerable{BaseItem}.</returns>
2016-07-15 19:54:34 +00:00
private async Task<QueryResult<BaseItem>> GetQueryResult(GetItems request, User user)
2013-02-21 01:33:05 +00:00
{
2014-01-22 17:05:23 +00:00
var item = string.IsNullOrEmpty(request.ParentId) ?
2014-03-03 02:17:12 +00:00
user == null ? _libraryManager.RootFolder : user.RootFolder :
2016-03-20 06:46:51 +00:00
_libraryManager.GetItemById(request.ParentId);
2013-02-21 01:33:05 +00:00
2015-11-15 22:30:47 +00:00
if (string.Equals(request.IncludeItemTypes, "Playlist", StringComparison.OrdinalIgnoreCase))
{
2016-03-20 06:46:51 +00:00
//item = user == null ? _libraryManager.RootFolder : user.RootFolder;
2015-11-15 22:30:47 +00:00
}
2016-02-05 17:04:38 +00:00
else if (string.Equals(request.IncludeItemTypes, "BoxSet", StringComparison.OrdinalIgnoreCase))
{
item = user == null ? _libraryManager.RootFolder : user.RootFolder;
}
2015-11-15 22:30:47 +00:00
2013-02-21 01:33:05 +00:00
// Default list type = children
2016-06-23 17:04:18 +00:00
var folder = item as Folder;
if (folder == null)
{
folder = user == null ? _libraryManager.RootFolder : _libraryManager.GetUserRootFolder();
}
2016-08-18 16:45:36 +00:00
if (request.Recursive || !string.IsNullOrEmpty(request.Ids) || user == null)
2013-10-15 22:16:39 +00:00
{
2016-06-23 17:04:18 +00:00
return await folder.GetItems(GetItemsQuery(request, user)).ConfigureAwait(false);
2013-10-15 22:16:39 +00:00
}
2015-07-14 19:04:16 +00:00
var userRoot = item as UserRootFolder;
2014-10-06 23:58:46 +00:00
2015-07-14 19:04:16 +00:00
if (userRoot == null)
{
2016-06-23 17:04:18 +00:00
return await folder.GetItems(GetItemsQuery(request, user)).ConfigureAwait(false);
2013-02-21 01:33:05 +00:00
}
2016-06-23 17:04:18 +00:00
IEnumerable<BaseItem> items = folder.GetChildren(user, true);
2015-07-14 19:04:16 +00:00
var itemsArray = items.ToArray();
2016-03-20 06:46:51 +00:00
return new QueryResult<BaseItem>
2014-10-06 23:58:46 +00:00
{
2015-07-14 19:04:16 +00:00
Items = itemsArray,
TotalRecordCount = itemsArray.Length
2016-03-20 06:46:51 +00:00
};
2013-02-21 01:33:05 +00:00
}
2014-10-06 23:58:46 +00:00
private InternalItemsQuery GetItemsQuery(GetItems request, User user)
2013-02-21 01:33:05 +00:00
{
2016-03-20 06:46:51 +00:00
var query = new InternalItemsQuery(user)
2014-10-06 23:58:46 +00:00
{
IsPlayed = request.IsPlayed,
MediaTypes = request.GetMediaTypes(),
IncludeItemTypes = request.GetIncludeItemTypes(),
ExcludeItemTypes = request.GetExcludeItemTypes(),
Recursive = request.Recursive,
SortBy = request.GetOrderBy(),
SortOrder = request.SortOrder ?? SortOrder.Ascending,
IsFavorite = request.IsFavorite,
2014-10-06 23:58:46 +00:00
Limit = request.Limit,
2014-10-08 01:37:45 +00:00
StartIndex = request.StartIndex,
IsMissing = request.IsMissing,
IsVirtualUnaired = request.IsVirtualUnaired,
IsUnaired = request.IsUnaired,
CollapseBoxSetItems = request.CollapseBoxSetItems,
NameLessThan = request.NameLessThan,
NameStartsWith = request.NameStartsWith,
NameStartsWithOrGreater = request.NameStartsWithOrGreater,
HasImdbId = request.HasImdbId,
IsPlaceHolder = request.IsPlaceHolder,
IsLocked = request.IsLocked,
IsInBoxSet = request.IsInBoxSet,
IsHD = request.IsHD,
Is3D = request.Is3D,
HasTvdbId = request.HasTvdbId,
HasTmdbId = request.HasTmdbId,
HasOverview = request.HasOverview,
HasOfficialRating = request.HasOfficialRating,
HasParentalRating = request.HasParentalRating,
HasSpecialFeature = request.HasSpecialFeature,
HasSubtitles = request.HasSubtitles,
HasThemeSong = request.HasThemeSong,
HasThemeVideo = request.HasThemeVideo,
HasTrailer = request.HasTrailer,
Tags = request.GetTags(),
OfficialRatings = request.GetOfficialRatings(),
2014-10-08 01:37:45 +00:00
Genres = request.GetGenres(),
2015-11-06 15:02:22 +00:00
GenreIds = request.GetGenreIds(),
2014-10-08 01:37:45 +00:00
Studios = request.GetStudios(),
2015-03-13 18:45:03 +00:00
StudioIds = request.GetStudioIds(),
2014-10-08 01:37:45 +00:00
Person = request.Person,
2015-03-18 16:40:16 +00:00
PersonIds = request.GetPersonIds(),
2014-10-08 01:37:45 +00:00
PersonTypes = request.GetPersonTypes(),
Years = request.GetYears(),
ImageTypes = request.GetImageTypes().ToArray(),
VideoTypes = request.GetVideoTypes().ToArray(),
2015-07-14 19:04:16 +00:00
AdjacentTo = request.AdjacentTo,
ItemIds = request.GetItemIds(),
MinPlayers = request.MinPlayers,
MaxPlayers = request.MaxPlayers,
MinCommunityRating = request.MinCommunityRating,
2016-03-20 06:46:51 +00:00
MinCriticRating = request.MinCriticRating,
2016-03-20 19:53:22 +00:00
ParentId = string.IsNullOrWhiteSpace(request.ParentId) ? (Guid?)null : new Guid(request.ParentId),
2016-03-20 20:04:27 +00:00
ParentIndexNumber = request.ParentIndexNumber,
2016-03-21 00:15:56 +00:00
AiredDuringSeason = request.AiredDuringSeason,
2016-05-09 03:13:38 +00:00
AlbumArtistStartsWithOrGreater = request.AlbumArtistStartsWithOrGreater,
2016-07-22 05:38:01 +00:00
EnableTotalRecordCount = request.EnableTotalRecordCount,
ExcludeItemIds = request.GetExcludeItemIds()
2014-10-06 23:58:46 +00:00
};
2014-10-08 01:37:45 +00:00
if (!string.IsNullOrWhiteSpace(request.Ids))
{
query.CollapseBoxSetItems = false;
}
2014-10-06 23:58:46 +00:00
foreach (var filter in request.GetFilters())
{
switch (filter)
{
case ItemFilter.Dislikes:
query.IsLiked = false;
break;
case ItemFilter.IsFavorite:
query.IsFavorite = true;
break;
case ItemFilter.IsFavoriteOrLikes:
query.IsFavoriteOrLiked = true;
break;
case ItemFilter.IsFolder:
query.IsFolder = true;
break;
case ItemFilter.IsNotFolder:
query.IsFolder = false;
break;
case ItemFilter.IsPlayed:
query.IsPlayed = true;
break;
case ItemFilter.IsResumable:
query.IsResumable = true;
break;
case ItemFilter.IsUnplayed:
query.IsPlayed = false;
break;
case ItemFilter.Likes:
query.IsLiked = true;
break;
}
}
2013-02-21 01:33:05 +00:00
2016-03-20 06:46:51 +00:00
if (!string.IsNullOrEmpty(request.MinPremiereDate))
{
query.MinPremiereDate = DateTime.Parse(request.MinPremiereDate, null, DateTimeStyles.RoundtripKind).ToUniversalTime();
}
if (!string.IsNullOrEmpty(request.MaxPremiereDate))
{
query.MaxPremiereDate = DateTime.Parse(request.MaxPremiereDate, null, DateTimeStyles.RoundtripKind).ToUniversalTime();
}
2016-03-20 19:53:22 +00:00
// Filter by Series Status
if (!string.IsNullOrEmpty(request.SeriesStatus))
{
query.SeriesStatuses = request.SeriesStatus.Split(',').Select(d => (SeriesStatus)Enum.Parse(typeof(SeriesStatus), d, true)).ToArray();
}
// Filter by Series AirDays
if (!string.IsNullOrEmpty(request.AirDays))
{
query.AirDays = request.AirDays.Split(',').Select(d => (DayOfWeek)Enum.Parse(typeof(DayOfWeek), d, true)).ToArray();
}
// ExcludeLocationTypes
if (!string.IsNullOrEmpty(request.ExcludeLocationTypes))
{
query.ExcludeLocationTypes = request.ExcludeLocationTypes.Split(',').Select(d => (LocationType)Enum.Parse(typeof(LocationType), d, true)).ToArray();
}
if (!string.IsNullOrEmpty(request.LocationTypes))
{
query.LocationTypes = request.LocationTypes.Split(',').Select(d => (LocationType)Enum.Parse(typeof(LocationType), d, true)).ToArray();
}
2016-06-25 00:29:39 +00:00
2016-03-21 03:10:37 +00:00
// Min official rating
2016-04-27 17:50:32 +00:00
if (!string.IsNullOrWhiteSpace(request.MinOfficialRating))
2016-03-21 03:10:37 +00:00
{
query.MinParentalRating = _localization.GetRatingLevel(request.MinOfficialRating);
}
// Max official rating
2016-04-27 17:50:32 +00:00
if (!string.IsNullOrWhiteSpace(request.MaxOfficialRating))
2016-03-21 03:10:37 +00:00
{
2016-04-27 17:50:32 +00:00
query.MaxParentalRating = _localization.GetRatingLevel(request.MaxOfficialRating);
2016-03-21 03:10:37 +00:00
}
2016-03-20 19:53:22 +00:00
2016-03-22 03:35:24 +00:00
// Artists
if (!string.IsNullOrEmpty(request.ArtistIds))
{
var artistIds = request.ArtistIds.Split(new[] { '|', ',' });
var artistItems = artistIds.Select(_libraryManager.GetItemById).Where(i => i != null).ToList();
query.ArtistNames = artistItems.Select(i => i.Name).ToArray();
}
2016-03-21 16:50:50 +00:00
// Artists
if (!string.IsNullOrEmpty(request.Artists))
{
query.ArtistNames = request.Artists.Split('|');
}
2016-07-22 22:10:39 +00:00
// ExcludeArtistIds
if (!string.IsNullOrEmpty(request.ExcludeArtistIds))
2016-07-22 17:54:43 +00:00
{
2016-07-22 22:10:39 +00:00
query.ExcludeArtistIds = request.ExcludeArtistIds.Split('|');
2016-07-22 17:54:43 +00:00
}
2016-03-21 16:50:50 +00:00
// Albums
if (!string.IsNullOrEmpty(request.Albums))
{
query.AlbumNames = request.Albums.Split('|');
}
2014-10-06 23:58:46 +00:00
return query;
2013-02-21 01:33:05 +00:00
}
}
/// <summary>
/// Class DateCreatedComparer
/// </summary>
public class DateCreatedComparer : IComparer<BaseItem>
{
/// <summary>
/// Compares the specified x.
/// </summary>
/// <param name="x">The x.</param>
/// <param name="y">The y.</param>
/// <returns>System.Int32.</returns>
public int Compare(BaseItem x, BaseItem y)
{
return x.DateCreated.CompareTo(y.DateCreated);
}
}
}