jellyfin/Emby.Server.Implementations/Library/UserViewManager.cs

363 lines
14 KiB
C#
Raw Normal View History

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using MediaBrowser.Controller.Channels;
2015-01-24 19:03:55 +00:00
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Dto;
2014-06-07 19:46:24 +00:00
using MediaBrowser.Controller.Entities;
using MediaBrowser.Controller.Entities.Audio;
2014-06-07 19:46:24 +00:00
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.LiveTv;
using MediaBrowser.Model.Channels;
using MediaBrowser.Model.Entities;
using MediaBrowser.Model.Globalization;
2014-06-07 19:46:24 +00:00
using MediaBrowser.Model.Library;
2014-07-13 21:03:57 +00:00
using MediaBrowser.Model.Querying;
2014-06-07 19:46:24 +00:00
namespace Emby.Server.Implementations.Library
2014-06-07 19:46:24 +00:00
{
public class UserViewManager : IUserViewManager
{
private readonly ILibraryManager _libraryManager;
private readonly ILocalizationManager _localizationManager;
private readonly IUserManager _userManager;
private readonly IChannelManager _channelManager;
private readonly ILiveTvManager _liveTvManager;
2015-01-24 19:03:55 +00:00
private readonly IServerConfigurationManager _config;
2014-06-07 19:46:24 +00:00
2015-10-04 19:09:13 +00:00
public UserViewManager(ILibraryManager libraryManager, ILocalizationManager localizationManager, IUserManager userManager, IChannelManager channelManager, ILiveTvManager liveTvManager, IServerConfigurationManager config)
2014-06-07 19:46:24 +00:00
{
_libraryManager = libraryManager;
_localizationManager = localizationManager;
_userManager = userManager;
_channelManager = channelManager;
_liveTvManager = liveTvManager;
2015-01-24 19:03:55 +00:00
_config = config;
2014-06-07 19:46:24 +00:00
}
2018-09-12 17:26:21 +00:00
public Folder[] GetUserViews(UserViewQuery query)
2014-06-07 19:46:24 +00:00
{
2014-09-14 15:10:51 +00:00
var user = _userManager.GetUserById(query.UserId);
2014-06-07 19:46:24 +00:00
2018-09-12 17:26:21 +00:00
var folders = _libraryManager.GetUserRootFolder()
2014-06-07 19:46:24 +00:00
.GetChildren(user, true)
.OfType<Folder>()
.ToList();
2015-11-18 05:49:20 +00:00
var groupedFolders = new List<ICollectionFolder>();
2014-06-07 19:46:24 +00:00
2015-03-15 19:22:04 +00:00
var list = new List<Folder>();
2015-11-18 05:49:20 +00:00
foreach (var folder in folders)
2015-03-15 19:22:04 +00:00
{
2015-11-14 16:58:01 +00:00
var collectionFolder = folder as ICollectionFolder;
var folderViewType = collectionFolder == null ? null : collectionFolder.CollectionType;
2015-09-15 18:09:44 +00:00
2015-11-14 16:58:01 +00:00
if (UserView.IsUserSpecific(folder))
{
2018-09-12 17:26:21 +00:00
list.Add(_libraryManager.GetNamedView(user, folder.Name, folder.Id, folderViewType, null));
2015-11-14 16:58:01 +00:00
continue;
2015-11-17 18:17:52 +00:00
}
2015-11-18 05:49:20 +00:00
if (collectionFolder != null && UserView.IsEligibleForGrouping(folder) && user.IsFolderGrouped(folder.Id))
{
groupedFolders.Add(collectionFolder);
continue;
}
if (query.PresetViews.Contains(folderViewType ?? string.Empty, StringComparer.OrdinalIgnoreCase))
{
2018-09-12 17:26:21 +00:00
list.Add(GetUserView(folder, folderViewType, string.Empty));
2015-09-14 17:28:42 +00:00
}
2015-11-14 16:58:01 +00:00
else
2015-09-14 17:28:42 +00:00
{
2015-11-18 05:49:20 +00:00
list.Add(folder);
2015-03-15 19:22:04 +00:00
}
}
2014-10-11 20:38:13 +00:00
2015-11-18 05:49:20 +00:00
foreach (var viewType in new[] { CollectionType.Movies, CollectionType.TvShows })
2014-06-07 19:46:24 +00:00
{
2018-09-12 17:26:21 +00:00
var parents = groupedFolders.Where(i => string.Equals(i.CollectionType, viewType, StringComparison.OrdinalIgnoreCase) || string.IsNullOrEmpty(i.CollectionType))
2015-11-18 05:49:20 +00:00
.ToList();
2015-04-15 21:59:20 +00:00
2015-11-18 05:49:20 +00:00
if (parents.Count > 0)
{
2017-10-16 06:10:55 +00:00
var localizationKey = string.Equals(viewType, CollectionType.TvShows, StringComparison.OrdinalIgnoreCase) ?
2017-10-17 19:49:39 +00:00
"TvShows" :
2017-10-16 06:10:55 +00:00
"Movies";
2017-10-13 05:43:11 +00:00
2018-09-12 17:26:21 +00:00
list.Add(GetUserView(parents, viewType, localizationKey, string.Empty, user, query.PresetViews));
2015-11-18 05:49:20 +00:00
}
2014-06-07 19:46:24 +00:00
}
2016-06-04 05:51:33 +00:00
if (_config.Configuration.EnableFolderView)
{
2017-10-13 05:43:11 +00:00
var name = _localizationManager.GetLocalizedString("Folders");
2018-09-12 17:26:21 +00:00
list.Add(_libraryManager.GetNamedView(name, CollectionType.Folders, string.Empty));
2016-06-04 05:51:33 +00:00
}
2014-06-07 19:46:24 +00:00
if (query.IncludeExternalContent)
{
2018-09-12 17:26:21 +00:00
var channelResult = _channelManager.GetChannelsInternal(new ChannelQuery
2014-06-07 19:46:24 +00:00
{
UserId = query.UserId
2018-09-12 17:26:21 +00:00
});
2014-06-07 19:46:24 +00:00
var channels = channelResult.Items;
2018-09-12 17:26:21 +00:00
list.AddRange(channels);
2014-06-07 19:46:24 +00:00
2018-09-12 17:26:21 +00:00
if (_liveTvManager.GetEnabledUsers().Select(i => i.Id).Contains(query.UserId))
2014-06-07 19:46:24 +00:00
{
2017-10-03 18:39:37 +00:00
list.Add(_liveTvManager.GetInternalLiveTvFolder(CancellationToken.None));
2014-06-07 19:46:24 +00:00
}
}
2018-09-12 17:26:21 +00:00
if (!query.IncludeHidden)
{
list = list.Where(i => !user.Configuration.MyMediaExcludes.Contains(i.Id.ToString("N"))).ToList();
}
2014-08-19 01:42:53 +00:00
var sorted = _libraryManager.Sort(list, user, new[] { ItemSortBy.SortName }, SortOrder.Ascending).ToList();
var orders = user.Configuration.OrderedViews.ToList();
return list
.OrderBy(i =>
{
var index = orders.IndexOf(i.Id.ToString("N"));
2015-11-17 18:17:52 +00:00
if (index == -1)
{
var view = i as UserView;
if (view != null)
{
2018-09-12 17:26:21 +00:00
if (!view.DisplayParentId.Equals(Guid.Empty))
2015-11-17 18:17:52 +00:00
{
index = orders.IndexOf(view.DisplayParentId.ToString("N"));
}
}
}
2014-08-19 01:42:53 +00:00
return index == -1 ? int.MaxValue : index;
})
.ThenBy(sorted.IndexOf)
2017-08-19 19:43:35 +00:00
.ThenBy(i => i.SortName)
.ToArray();
2014-06-07 19:46:24 +00:00
}
2018-09-12 17:26:21 +00:00
public UserView GetUserSubViewWithName(string name, Guid parentId, string type, string sortName)
2014-11-11 03:41:55 +00:00
{
2015-04-20 18:04:02 +00:00
var uniqueId = parentId + "subview" + type;
2018-09-12 17:26:21 +00:00
return _libraryManager.GetNamedView(name, parentId, type, sortName, uniqueId);
2014-11-11 03:41:55 +00:00
}
2018-09-12 17:26:21 +00:00
public UserView GetUserSubView(Guid parentId, string type, string localizationKey, string sortName)
2014-06-07 19:46:24 +00:00
{
2017-10-13 05:43:11 +00:00
var name = _localizationManager.GetLocalizedString(localizationKey);
2014-06-07 19:46:24 +00:00
2018-09-12 17:26:21 +00:00
return GetUserSubViewWithName(name, parentId, type, sortName);
2014-06-07 19:46:24 +00:00
}
2014-07-30 03:31:35 +00:00
2018-09-12 17:26:21 +00:00
private Folder GetUserView(List<ICollectionFolder> parents, string viewType, string localizationKey, string sortName, User user, string[] presetViews)
2014-07-30 03:31:35 +00:00
{
2015-11-18 05:49:20 +00:00
if (parents.Count == 1 && parents.All(i => string.Equals(i.CollectionType, viewType, StringComparison.OrdinalIgnoreCase)))
2015-04-15 21:59:20 +00:00
{
2015-11-17 18:17:52 +00:00
if (!presetViews.Contains(viewType, StringComparer.OrdinalIgnoreCase))
2015-11-14 16:58:01 +00:00
{
return (Folder)parents[0];
}
2018-09-12 17:26:21 +00:00
return GetUserView((Folder)parents[0], viewType, string.Empty);
2015-04-15 21:59:20 +00:00
}
2015-04-20 18:04:02 +00:00
2017-10-13 05:43:11 +00:00
var name = _localizationManager.GetLocalizedString(localizationKey);
2018-09-12 17:26:21 +00:00
return _libraryManager.GetNamedView(user, name, viewType, sortName);
2014-07-30 03:31:35 +00:00
}
2018-09-12 17:26:21 +00:00
public UserView GetUserView(Folder parent, string viewType, string sortName)
2015-03-15 19:22:04 +00:00
{
2018-09-12 17:26:21 +00:00
return _libraryManager.GetShadowView(parent, viewType, sortName);
2015-09-15 18:09:44 +00:00
}
2017-05-21 07:25:49 +00:00
public List<Tuple<BaseItem, List<BaseItem>>> GetLatestItems(LatestItemsQuery request, DtoOptions options)
{
var user = _userManager.GetUserById(request.UserId);
2017-05-21 07:25:49 +00:00
var libraryItems = GetItemsForLatestItems(user, request, options);
var list = new List<Tuple<BaseItem, List<BaseItem>>>();
2015-10-29 19:01:04 +00:00
foreach (var item in libraryItems)
{
// Only grab the index container for media
var container = item.IsFolder || !request.GroupItems ? null : item.LatestItemsIndexContainer;
if (container == null)
{
list.Add(new Tuple<BaseItem, List<BaseItem>>(null, new List<BaseItem> { item }));
}
else
{
var current = list.FirstOrDefault(i => i.Item1 != null && i.Item1.Id == container.Id);
if (current != null)
{
current.Item2.Add(item);
}
else
{
list.Add(new Tuple<BaseItem, List<BaseItem>>(container, new List<BaseItem> { item }));
}
}
if (list.Count >= request.Limit)
{
break;
}
}
return list;
}
private List<BaseItem> GetItemsForLatestItems(User user, LatestItemsQuery request, DtoOptions options)
{
2016-06-12 05:03:52 +00:00
var parentId = request.ParentId;
var includeItemTypes = request.IncludeItemTypes;
var limit = request.Limit ?? 10;
2016-11-21 08:54:53 +00:00
var parents = new List<BaseItem>();
2018-09-12 17:26:21 +00:00
if (!parentId.Equals(Guid.Empty))
2015-11-02 17:25:01 +00:00
{
2018-09-12 17:26:21 +00:00
var parentItem = _libraryManager.GetItemById(parentId);
var parentItemChannel = parentItem as Channel;
if (parentItemChannel != null)
{
return _channelManager.GetLatestChannelItemsInternal(new InternalItemsQuery(user)
{
ChannelIds = new[] { parentId },
2018-09-12 17:26:21 +00:00
IsPlayed = request.IsPlayed,
StartIndex = request.StartIndex,
Limit = request.Limit,
IncludeItemTypes = request.IncludeItemTypes,
EnableTotalRecordCount = false
}, CancellationToken.None).Result.Items.ToList();
}
var parent = parentItem as Folder;
2016-11-21 08:54:53 +00:00
if (parent != null)
{
parents.Add(parent);
}
}
2017-02-17 21:11:13 +00:00
var isPlayed = request.IsPlayed;
if (parents.OfType<ICollectionFolder>().Any(i => string.Equals(i.CollectionType, CollectionType.Music, StringComparison.OrdinalIgnoreCase)))
{
isPlayed = null;
}
2016-11-21 08:54:53 +00:00
if (parents.Count == 0)
{
2018-09-12 17:26:21 +00:00
parents = _libraryManager.GetUserRootFolder().GetChildren(user, true)
2016-11-21 08:54:53 +00:00
.Where(i => i is Folder)
.Where(i => !user.Configuration.LatestItemsExcludes.Contains(i.Id.ToString("N")))
.ToList();
2015-11-02 17:25:01 +00:00
}
2016-11-21 08:54:53 +00:00
if (parents.Count == 0)
2016-03-26 16:58:03 +00:00
{
return new List<BaseItem>();
}
2018-09-12 17:26:21 +00:00
if (includeItemTypes.Length == 0)
{
2019-01-07 23:27:46 +00:00
// Handle situations with the grouping setting, e.g. movies showing up in tv, etc.
2018-09-12 17:26:21 +00:00
// Thanks to mixed content libraries included in the UserView
var hasCollectionType = parents.OfType<UserView>().ToArray();
if (hasCollectionType.Length > 0)
{
if (hasCollectionType.All(i => string.Equals(i.CollectionType, CollectionType.Movies, StringComparison.OrdinalIgnoreCase)))
{
includeItemTypes = new string[] { "Movie" };
}
else if (hasCollectionType.All(i => string.Equals(i.CollectionType, CollectionType.TvShows, StringComparison.OrdinalIgnoreCase)))
{
includeItemTypes = new string[] { "Episode" };
}
}
}
2017-08-01 16:45:57 +00:00
var mediaTypes = new List<string>();
if (includeItemTypes.Length == 0)
{
foreach (var parent in parents.OfType<ICollectionFolder>())
{
switch (parent.CollectionType)
{
case CollectionType.Books:
mediaTypes.Add(MediaType.Book);
2018-09-12 17:26:21 +00:00
mediaTypes.Add(MediaType.Audio);
2017-08-01 16:45:57 +00:00
break;
case CollectionType.Music:
mediaTypes.Add(MediaType.Audio);
break;
case CollectionType.Photos:
mediaTypes.Add(MediaType.Photo);
mediaTypes.Add(MediaType.Video);
break;
case CollectionType.HomeVideos:
mediaTypes.Add(MediaType.Photo);
mediaTypes.Add(MediaType.Video);
break;
default:
mediaTypes.Add(MediaType.Video);
break;
}
}
mediaTypes = mediaTypes.Distinct().ToList();
}
var excludeItemTypes = includeItemTypes.Length == 0 && mediaTypes.Count == 0 ? new[]
2016-03-19 05:04:38 +00:00
{
2016-06-12 05:03:52 +00:00
typeof(Person).Name,
typeof(Studio).Name,
typeof(Year).Name,
typeof(MusicGenre).Name,
typeof(Genre).Name
2016-03-19 05:04:38 +00:00
2018-09-12 17:26:21 +00:00
} : Array.Empty<string>();
2015-11-02 17:25:01 +00:00
2017-06-03 07:36:32 +00:00
var query = new InternalItemsQuery(user)
{
2015-10-29 19:01:04 +00:00
IncludeItemTypes = includeItemTypes,
2018-09-12 17:26:21 +00:00
OrderBy = new[] { new ValueTuple<string, SortOrder>(ItemSortBy.DateCreated, SortOrder.Descending) },
2015-11-02 17:25:01 +00:00
IsFolder = includeItemTypes.Length == 0 ? false : (bool?)null,
ExcludeItemTypes = excludeItemTypes,
2017-01-09 17:05:34 +00:00
IsVirtualItem = false,
2016-06-12 05:03:52 +00:00
Limit = limit * 5,
2017-05-21 07:25:49 +00:00
IsPlayed = isPlayed,
2017-08-01 16:45:57 +00:00
DtoOptions = options,
2018-12-28 15:48:26 +00:00
MediaTypes = mediaTypes.ToArray()
2017-06-03 07:36:32 +00:00
};
2017-06-03 07:36:32 +00:00
if (parents.Count == 0)
{
return _libraryManager.GetItemList(query, false);
}
return _libraryManager.GetItemList(query, parents);
}
2014-06-07 19:46:24 +00:00
}
}