jellyfin/MediaBrowser.Server.Implementations/TV/TVSeriesManager.cs

225 lines
8.1 KiB
C#
Raw Normal View History

using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.TV;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.Querying;
using System;
using System.Collections.Generic;
using System.Linq;
namespace MediaBrowser.Server.Implementations.TV
{
public class TVSeriesManager : ITVSeriesManager
{
private readonly IUserManager _userManager;
private readonly IUserDataManager _userDataManager;
private readonly ILibraryManager _libraryManager;
public TVSeriesManager(IUserManager userManager, IUserDataManager userDataManager, ILibraryManager libraryManager)
{
_userManager = userManager;
_userDataManager = userDataManager;
_libraryManager = libraryManager;
}
public QueryResult<BaseItem> GetNextUp(NextUpQuery request)
{
2014-09-14 15:10:51 +00:00
var user = _userManager.GetUserById(request.UserId);
if (user == null)
{
throw new ArgumentException("User not found");
}
var parentIds = string.IsNullOrEmpty(request.ParentId)
? new string[] { }
: new[] { request.ParentId };
2016-05-02 05:32:04 +00:00
string presentationUniqueKey = null;
int? limit = null;
if (!string.IsNullOrWhiteSpace(request.SeriesId))
{
var series = _libraryManager.GetItemById(request.SeriesId);
if (series != null)
{
presentationUniqueKey = series.PresentationUniqueKey;
limit = 1;
}
}
2016-03-20 06:46:51 +00:00
var items = _libraryManager.GetItemList(new InternalItemsQuery(user)
2015-10-28 19:40:38 +00:00
{
2015-10-29 13:28:05 +00:00
IncludeItemTypes = new[] { typeof(Series).Name },
2016-05-02 05:32:04 +00:00
SortOrder = SortOrder.Ascending,
PresentationUniqueKey = presentationUniqueKey,
Limit = limit
2015-10-28 19:40:38 +00:00
2015-11-11 14:56:31 +00:00
}, parentIds).Cast<Series>();
// Avoid implicitly captured closure
var episodes = GetNextUpEpisodes(request, user, items);
return GetResult(episodes, null, request);
}
public QueryResult<BaseItem> GetNextUp(NextUpQuery request, IEnumerable<Folder> parentsFolders)
{
2014-09-14 15:10:51 +00:00
var user = _userManager.GetUserById(request.UserId);
if (user == null)
{
throw new ArgumentException("User not found");
}
2016-05-02 05:32:04 +00:00
string presentationUniqueKey = null;
int? limit = null;
if (!string.IsNullOrWhiteSpace(request.SeriesId))
{
var series = _libraryManager.GetItemById(request.SeriesId);
if (series != null)
{
presentationUniqueKey = series.PresentationUniqueKey;
limit = 1;
}
}
2016-03-20 06:46:51 +00:00
var items = _libraryManager.GetItemList(new InternalItemsQuery(user)
2015-10-29 13:28:05 +00:00
{
IncludeItemTypes = new[] { typeof(Series).Name },
2016-05-02 05:32:04 +00:00
SortOrder = SortOrder.Ascending,
PresentationUniqueKey = presentationUniqueKey,
Limit = limit
2015-10-29 13:28:05 +00:00
2015-11-11 14:56:31 +00:00
}, parentsFolders.Select(i => i.Id.ToString("N"))).Cast<Series>();
// Avoid implicitly captured closure
var episodes = GetNextUpEpisodes(request, user, items);
return GetResult(episodes, null, request);
}
public IEnumerable<Episode> GetNextUpEpisodes(NextUpQuery request, User user, IEnumerable<Series> series)
{
// Avoid implicitly captured closure
var currentUser = user;
2016-05-02 05:32:04 +00:00
return series
.AsParallel()
.Select(i => GetNextUp(i, currentUser))
// Include if an episode was found, and either the series is not unwatched or the specific series was requested
.Where(i => i.Item1 != null && (!i.Item3 || !string.IsNullOrWhiteSpace(request.SeriesId)))
2016-05-02 05:32:04 +00:00
.OrderByDescending(i => i.Item2)
.ThenByDescending(i => i.Item1.PremiereDate ?? DateTime.MinValue)
.Select(i => i.Item1);
}
/// <summary>
/// Gets the next up.
/// </summary>
/// <param name="series">The series.</param>
/// <param name="user">The user.</param>
/// <returns>Task{Episode}.</returns>
private Tuple<Episode, DateTime, bool> GetNextUp(Series series, User user)
{
2016-06-14 19:21:26 +00:00
var firstUnwatchedEpisode = _libraryManager.GetItemList(new InternalItemsQuery(user)
{
2016-06-14 19:21:26 +00:00
AncestorWithPresentationUniqueKey = series.PresentationUniqueKey,
IncludeItemTypes = new[] { typeof(Episode).Name },
SortBy = new[] { ItemSortBy.SortName },
SortOrder = SortOrder.Ascending,
Limit = 1,
IsPlayed = false,
2016-06-15 02:18:19 +00:00
IsVirtualItem = false,
ParentIndexNumberNotEquals = 0
2016-06-04 00:15:14 +00:00
2016-06-14 19:21:26 +00:00
}).Cast<Episode>().FirstOrDefault();
2016-06-14 20:59:30 +00:00
// series is fully played
2016-06-14 19:21:26 +00:00
if (firstUnwatchedEpisode == null)
{
2016-06-14 19:21:26 +00:00
return new Tuple<Episode, DateTime, bool>(null, DateTime.MinValue, true);
}
2016-06-14 19:21:26 +00:00
var lastWatchedEpisode = _libraryManager.GetItemList(new InternalItemsQuery(user)
2016-06-04 00:15:14 +00:00
{
2016-06-14 19:21:26 +00:00
AncestorWithPresentationUniqueKey = series.PresentationUniqueKey,
IncludeItemTypes = new[] { typeof(Episode).Name },
SortBy = new[] { ItemSortBy.DatePlayed },
SortOrder = SortOrder.Descending,
Limit = 1,
2016-06-15 02:18:19 +00:00
IsVirtualItem = false,
ParentIndexNumberNotEquals = 0
2016-06-14 19:21:26 +00:00
}).FirstOrDefault();
//// Get them in display order, then reverse
//var allEpisodes = series.GetEpisodes(user, false, false)
// .Where(i => !i.ParentIndexNumber.HasValue || i.ParentIndexNumber.Value != 0)
// .Reverse()
// .ToList();
//Episode lastWatched = null;
//var lastWatchedDate = DateTime.MinValue;
//Episode nextUp = null;
//// Go back starting with the most recent episodes
//foreach (var episode in allEpisodes)
//{
// var userData = _userDataManager.GetUserData(user, episode);
// if (userData.Played)
// {
// if (lastWatched != null || nextUp == null)
// {
// break;
// }
// lastWatched = episode;
// lastWatchedDate = userData.LastPlayedDate ?? DateTime.MinValue;
// }
// else
// {
// nextUp = episode;
// }
//}
if (lastWatchedEpisode != null)
{
var userData = _userDataManager.GetUserData(user, lastWatchedEpisode);
2016-06-04 00:15:14 +00:00
2016-06-14 19:21:26 +00:00
if (userData.LastPlayedDate.HasValue)
{
return new Tuple<Episode, DateTime, bool>(firstUnwatchedEpisode, userData.LastPlayedDate.Value, false);
}
2016-06-04 00:15:14 +00:00
}
2015-01-23 06:15:15 +00:00
// Return the first episode
2016-06-14 19:21:26 +00:00
return new Tuple<Episode, DateTime, bool>(firstUnwatchedEpisode, DateTime.MinValue, true);
}
private QueryResult<BaseItem> GetResult(IEnumerable<BaseItem> items, int? totalRecordLimit, NextUpQuery query)
{
var itemsArray = totalRecordLimit.HasValue ? items.Take(totalRecordLimit.Value).ToArray() : items.ToArray();
var totalCount = itemsArray.Length;
if (query.Limit.HasValue)
{
itemsArray = itemsArray.Skip(query.StartIndex ?? 0).Take(query.Limit.Value).ToArray();
}
else if (query.StartIndex.HasValue)
{
itemsArray = itemsArray.Skip(query.StartIndex.Value).ToArray();
}
return new QueryResult<BaseItem>
{
TotalRecordCount = totalCount,
Items = itemsArray
};
}
}
}