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

269 lines
9.3 KiB
C#
Raw Normal View History

using System;
using System.Collections.Generic;
using System.Linq;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Dto;
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;
2016-11-03 07:14:14 +00:00
namespace Emby.Server.Implementations.TV
{
public class TVSeriesManager : ITVSeriesManager
{
private readonly IUserManager _userManager;
private readonly IUserDataManager _userDataManager;
private readonly ILibraryManager _libraryManager;
2016-07-01 15:51:35 +00:00
private readonly IServerConfigurationManager _config;
2016-07-01 15:51:35 +00:00
public TVSeriesManager(IUserManager userManager, IUserDataManager userDataManager, ILibraryManager libraryManager, IServerConfigurationManager config)
{
_userManager = userManager;
_userDataManager = userDataManager;
_libraryManager = libraryManager;
2016-07-01 15:51:35 +00:00
_config = config;
}
2017-05-21 07:25:49 +00:00
public QueryResult<BaseItem> GetNextUp(NextUpQuery request, DtoOptions dtoOptions)
{
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;
2018-09-12 17:26:21 +00:00
if (!string.IsNullOrEmpty(request.SeriesId))
2016-05-02 05:32:04 +00:00
{
2017-08-01 16:45:57 +00:00
var series = _libraryManager.GetItemById(request.SeriesId) as Series;
2016-05-02 05:32:04 +00:00
if (series != null)
{
2016-07-01 15:51:35 +00:00
presentationUniqueKey = GetUniqueSeriesKey(series);
2016-05-02 05:32:04 +00:00
}
}
2018-09-12 17:26:21 +00:00
if (!string.IsNullOrEmpty(presentationUniqueKey))
2017-08-01 16:45:57 +00:00
{
return GetResult(GetNextUpEpisodes(request, user, new[] { presentationUniqueKey }, dtoOptions), request);
}
2018-09-12 17:26:21 +00:00
var parentIdGuid = string.IsNullOrEmpty(request.ParentId) ? (Guid?)null : new Guid(request.ParentId);
2017-10-02 20:18:27 +00:00
2018-09-12 17:26:21 +00:00
BaseItem[] parents;
2017-10-02 20:18:27 +00:00
if (parentIdGuid.HasValue)
{
var parent = _libraryManager.GetItemById(parentIdGuid.Value);
2018-09-12 17:26:21 +00:00
2017-10-02 20:18:27 +00:00
if (parent != null)
{
2018-09-12 17:26:21 +00:00
parents = new[] { parent };
}
else
{
parents = Array.Empty<BaseItem>();
2017-10-02 20:18:27 +00:00
}
}
else
{
2018-09-12 17:26:21 +00:00
parents = _libraryManager.GetUserRootFolder().GetChildren(user, true)
2017-10-02 20:18:27 +00:00
.Where(i => i is Folder)
.Where(i => !user.Configuration.LatestItemsExcludes.Contains(i.Id.ToString("N")))
2018-09-12 17:26:21 +00:00
.ToArray();
2017-10-02 20:18:27 +00:00
}
2016-07-05 06:09:11 +00:00
2017-10-01 17:26:09 +00:00
return GetNextUp(request, parents, dtoOptions);
}
2018-09-12 17:26:21 +00:00
public QueryResult<BaseItem> GetNextUp(NextUpQuery request, BaseItem[] parentsFolders, DtoOptions dtoOptions)
{
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;
2018-09-12 17:26:21 +00:00
if (!string.IsNullOrEmpty(request.SeriesId))
2016-05-02 05:32:04 +00:00
{
2017-08-01 16:45:57 +00:00
var series = _libraryManager.GetItemById(request.SeriesId) as Series;
2016-05-02 05:32:04 +00:00
if (series != null)
{
2016-07-01 15:51:35 +00:00
presentationUniqueKey = GetUniqueSeriesKey(series);
2016-05-02 05:32:04 +00:00
limit = 1;
}
}
2018-09-12 17:26:21 +00:00
if (!string.IsNullOrEmpty(presentationUniqueKey))
2017-08-01 16:45:57 +00:00
{
2017-10-02 20:18:27 +00:00
return GetResult(GetNextUpEpisodes(request, user, new[] { presentationUniqueKey }, dtoOptions), request);
2017-08-01 16:45:57 +00:00
}
if (limit.HasValue)
2016-07-05 06:09:11 +00:00
{
limit = limit.Value + 10;
}
2016-03-20 06:46:51 +00:00
var items = _libraryManager.GetItemList(new InternalItemsQuery(user)
2015-10-29 13:28:05 +00:00
{
2017-08-01 16:45:57 +00:00
IncludeItemTypes = new[] { typeof(Episode).Name },
2018-09-12 17:26:21 +00:00
OrderBy = new[] { new ValueTuple<string, SortOrder>(ItemSortBy.DatePlayed, SortOrder.Descending) },
2017-08-01 16:45:57 +00:00
SeriesPresentationUniqueKey = presentationUniqueKey,
2016-12-12 05:49:19 +00:00
Limit = limit,
2019-01-13 20:37:13 +00:00
DtoOptions = new DtoOptions
2016-12-12 05:49:19 +00:00
{
2017-08-19 19:43:35 +00:00
Fields = new ItemFields[]
2016-12-12 05:49:19 +00:00
{
2017-08-01 16:45:57 +00:00
ItemFields.SeriesPresentationUniqueKey
2016-12-12 05:49:19 +00:00
},
EnableImages = false
2017-08-01 16:45:57 +00:00
},
GroupBySeriesPresentationUniqueKey = true
2015-10-29 13:28:05 +00:00
2018-09-12 17:26:21 +00:00
}, parentsFolders.ToList()).Cast<Episode>().Select(GetUniqueSeriesKey);
// Avoid implicitly captured closure
2017-05-21 07:25:49 +00:00
var episodes = GetNextUpEpisodes(request, user, items, dtoOptions);
2017-03-21 17:31:40 +00:00
return GetResult(episodes, request);
}
2017-05-21 07:25:49 +00:00
public IEnumerable<Episode> GetNextUpEpisodes(NextUpQuery request, User user, IEnumerable<string> seriesKeys, DtoOptions dtoOptions)
{
// Avoid implicitly captured closure
var currentUser = user;
2016-12-12 08:53:25 +00:00
var allNextUp = seriesKeys
2017-05-21 07:25:49 +00:00
.Select(i => GetNextUp(i, currentUser, dtoOptions));
2016-12-12 08:53:25 +00:00
//allNextUp = allNextUp.OrderByDescending(i => i.Item1);
2016-07-23 20:27:22 +00:00
// If viewing all next up for all series, remove first episodes
2016-12-12 05:49:19 +00:00
// But if that returns empty, keep those first episodes (avoid completely empty view)
2018-09-12 17:26:21 +00:00
var alwaysEnableFirstEpisode = !string.IsNullOrEmpty(request.SeriesId);
var anyFound = false;
2016-07-23 20:27:22 +00:00
return allNextUp
2016-12-12 05:49:19 +00:00
.Where(i =>
{
if (alwaysEnableFirstEpisode || i.Item1 != DateTime.MinValue)
{
anyFound = true;
return true;
}
if (!anyFound && i.Item1 == DateTime.MinValue)
2016-12-12 05:49:19 +00:00
{
return true;
}
2016-12-15 06:41:10 +00:00
return false;
2016-12-12 05:49:19 +00:00
})
2016-11-21 17:17:26 +00:00
.Select(i => i.Item2())
2017-03-21 17:31:40 +00:00
.Where(i => i != null);
}
private static string GetUniqueSeriesKey(Episode episode)
2017-08-01 16:45:57 +00:00
{
return episode.SeriesPresentationUniqueKey;
}
private static string GetUniqueSeriesKey(Series series)
2016-07-01 15:51:35 +00:00
{
return series.GetPresentationUniqueKey();
2016-07-01 15:51:35 +00:00
}
/// <summary>
/// Gets the next up.
/// </summary>
/// <returns>Task{Episode}.</returns>
2017-05-21 07:25:49 +00:00
private Tuple<DateTime, Func<Episode>> GetNextUp(string seriesKey, User user, DtoOptions dtoOptions)
{
2016-06-29 16:31:01 +00:00
var lastWatchedEpisode = _libraryManager.GetItemList(new InternalItemsQuery(user)
{
2017-05-24 19:12:55 +00:00
AncestorWithPresentationUniqueKey = null,
SeriesPresentationUniqueKey = seriesKey,
2016-06-14 19:21:26 +00:00
IncludeItemTypes = new[] { typeof(Episode).Name },
2018-09-12 17:26:21 +00:00
OrderBy = new[] { new ValueTuple<string, SortOrder>(ItemSortBy.SortName, SortOrder.Descending) },
2016-06-29 16:31:01 +00:00
IsPlayed = true,
2016-06-14 19:21:26 +00:00
Limit = 1,
2016-12-12 05:49:19 +00:00
ParentIndexNumberNotEquals = 0,
2019-01-13 20:37:13 +00:00
DtoOptions = new DtoOptions
2016-12-12 05:49:19 +00:00
{
2017-08-19 19:43:35 +00:00
Fields = new ItemFields[]
2016-12-12 05:49:19 +00:00
{
2017-05-24 19:12:55 +00:00
ItemFields.SortName
2016-12-12 05:49:19 +00:00
},
EnableImages = false
}
2016-06-04 00:15:14 +00:00
2016-06-29 16:31:01 +00:00
}).FirstOrDefault();
2016-11-21 17:17:26 +00:00
Func<Episode> getEpisode = () =>
2016-06-04 00:15:14 +00:00
{
2016-11-21 17:17:26 +00:00
return _libraryManager.GetItemList(new InternalItemsQuery(user)
{
2017-05-24 19:12:55 +00:00
AncestorWithPresentationUniqueKey = null,
SeriesPresentationUniqueKey = seriesKey,
2016-11-21 17:17:26 +00:00
IncludeItemTypes = new[] { typeof(Episode).Name },
2018-09-12 17:26:21 +00:00
OrderBy = new[] { new ValueTuple<string, SortOrder>(ItemSortBy.SortName, SortOrder.Ascending) },
2016-11-21 17:17:26 +00:00
Limit = 1,
IsPlayed = false,
IsVirtualItem = false,
ParentIndexNumberNotEquals = 0,
2017-05-21 07:25:49 +00:00
MinSortName = lastWatchedEpisode == null ? null : lastWatchedEpisode.SortName,
DtoOptions = dtoOptions
2016-11-21 17:17:26 +00:00
}).Cast<Episode>().FirstOrDefault();
};
2016-06-14 19:21:26 +00:00
2016-11-21 17:17:26 +00:00
if (lastWatchedEpisode != null)
2016-06-14 19:21:26 +00:00
{
var userData = _userDataManager.GetUserData(user, lastWatchedEpisode);
2016-06-04 00:15:14 +00:00
2016-07-01 15:51:35 +00:00
var lastWatchedDate = userData.LastPlayedDate ?? DateTime.MinValue.AddDays(1);
2016-11-21 17:17:26 +00:00
return new Tuple<DateTime, Func<Episode>>(lastWatchedDate, getEpisode);
2016-06-04 00:15:14 +00:00
}
2015-01-23 06:15:15 +00:00
// Return the first episode
2016-11-21 17:17:26 +00:00
return new Tuple<DateTime, Func<Episode>>(DateTime.MinValue, getEpisode);
}
private static QueryResult<BaseItem> GetResult(IEnumerable<BaseItem> items, NextUpQuery query)
{
2017-03-21 17:31:40 +00:00
int totalCount = 0;
2017-03-21 17:31:40 +00:00
if (query.EnableTotalRecordCount)
{
2017-03-21 17:31:40 +00:00
var list = items.ToList();
totalCount = list.Count;
items = list;
}
2017-03-21 17:31:40 +00:00
if (query.StartIndex.HasValue)
{
items = items.Skip(query.StartIndex.Value);
}
if (query.Limit.HasValue)
{
2017-03-21 17:31:40 +00:00
items = items.Take(query.Limit.Value);
}
return new QueryResult<BaseItem>
{
TotalRecordCount = totalCount,
2017-03-21 17:31:40 +00:00
Items = items.ToArray()
};
}
}
}