| | | 1 | | #nullable disable |
| | | 2 | | |
| | | 3 | | #pragma warning disable CS1591 |
| | | 4 | | |
| | | 5 | | using System; |
| | | 6 | | using System.Collections.Generic; |
| | | 7 | | using System.Linq; |
| | | 8 | | using System.Threading; |
| | | 9 | | using Jellyfin.Data; |
| | | 10 | | using Jellyfin.Data.Enums; |
| | | 11 | | using Jellyfin.Database.Implementations.Entities; |
| | | 12 | | using Jellyfin.Database.Implementations.Enums; |
| | | 13 | | using Jellyfin.Extensions; |
| | | 14 | | using MediaBrowser.Controller.Channels; |
| | | 15 | | using MediaBrowser.Controller.Configuration; |
| | | 16 | | using MediaBrowser.Controller.Dto; |
| | | 17 | | using MediaBrowser.Controller.Entities; |
| | | 18 | | using MediaBrowser.Controller.Library; |
| | | 19 | | using MediaBrowser.Controller.LiveTv; |
| | | 20 | | using MediaBrowser.Model.Channels; |
| | | 21 | | using MediaBrowser.Model.Globalization; |
| | | 22 | | using MediaBrowser.Model.Library; |
| | | 23 | | using MediaBrowser.Model.Querying; |
| | | 24 | | |
| | | 25 | | namespace Emby.Server.Implementations.Library |
| | | 26 | | { |
| | | 27 | | public class UserViewManager : IUserViewManager |
| | | 28 | | { |
| | | 29 | | private readonly ILibraryManager _libraryManager; |
| | | 30 | | private readonly ILocalizationManager _localizationManager; |
| | | 31 | | |
| | | 32 | | private readonly IChannelManager _channelManager; |
| | | 33 | | private readonly ILiveTvManager _liveTvManager; |
| | | 34 | | private readonly IServerConfigurationManager _config; |
| | | 35 | | |
| | | 36 | | public UserViewManager(ILibraryManager libraryManager, ILocalizationManager localizationManager, IChannelManager |
| | | 37 | | { |
| | 27 | 38 | | _libraryManager = libraryManager; |
| | 27 | 39 | | _localizationManager = localizationManager; |
| | 27 | 40 | | _channelManager = channelManager; |
| | 27 | 41 | | _liveTvManager = liveTvManager; |
| | 27 | 42 | | _config = config; |
| | 27 | 43 | | } |
| | | 44 | | |
| | | 45 | | public Folder[] GetUserViews(UserViewQuery query) |
| | | 46 | | { |
| | 1 | 47 | | var user = query.User; |
| | | 48 | | |
| | 1 | 49 | | var folders = _libraryManager.GetUserRootFolder() |
| | 1 | 50 | | .GetChildren(user, true) |
| | 1 | 51 | | .OfType<Folder>() |
| | 1 | 52 | | .ToList(); |
| | | 53 | | |
| | 1 | 54 | | var groupedFolders = new List<ICollectionFolder>(); |
| | 1 | 55 | | var list = new List<Folder>(); |
| | | 56 | | |
| | 4 | 57 | | foreach (var folder in folders) |
| | | 58 | | { |
| | 1 | 59 | | var collectionFolder = folder as ICollectionFolder; |
| | 1 | 60 | | var folderViewType = collectionFolder?.CollectionType; |
| | | 61 | | |
| | | 62 | | // Playlist and BoxSet libraries require special handling because the folder only references linked item |
| | 1 | 63 | | if (folderViewType == CollectionType.playlists || folderViewType == CollectionType.boxsets) |
| | | 64 | | { |
| | 1 | 65 | | var itemKind = folderViewType == CollectionType.playlists |
| | 1 | 66 | | ? BaseItemKind.Playlist |
| | 1 | 67 | | : BaseItemKind.BoxSet; |
| | | 68 | | |
| | 1 | 69 | | if (!HasVisibleItem(itemKind, folders, user)) |
| | | 70 | | { |
| | | 71 | | continue; |
| | | 72 | | } |
| | | 73 | | } |
| | | 74 | | |
| | 0 | 75 | | if (UserView.IsUserSpecific(folder)) |
| | | 76 | | { |
| | 0 | 77 | | list.Add(_libraryManager.GetNamedView(user, folder.Name, folder.Id, folderViewType, null)); |
| | 0 | 78 | | continue; |
| | | 79 | | } |
| | | 80 | | |
| | 0 | 81 | | if (collectionFolder is not null && UserView.IsEligibleForGrouping(folder) && user.IsFolderGrouped(folde |
| | | 82 | | { |
| | 0 | 83 | | groupedFolders.Add(collectionFolder); |
| | 0 | 84 | | continue; |
| | | 85 | | } |
| | | 86 | | |
| | 0 | 87 | | if (query.PresetViews.Contains(folderViewType)) |
| | | 88 | | { |
| | 0 | 89 | | list.Add(GetUserView(folder, folderViewType, string.Empty)); |
| | | 90 | | } |
| | | 91 | | else |
| | | 92 | | { |
| | 0 | 93 | | list.Add(folder); |
| | | 94 | | } |
| | | 95 | | } |
| | | 96 | | |
| | 6 | 97 | | foreach (var viewType in new[] { CollectionType.movies, CollectionType.tvshows }) |
| | | 98 | | { |
| | 2 | 99 | | var parents = groupedFolders.Where(i => i.CollectionType == viewType || i.CollectionType is null) |
| | 2 | 100 | | .ToList(); |
| | | 101 | | |
| | 2 | 102 | | if (parents.Count > 0) |
| | | 103 | | { |
| | 0 | 104 | | var localizationKey = viewType == CollectionType.tvshows |
| | 0 | 105 | | ? "TvShows" |
| | 0 | 106 | | : "Movies"; |
| | | 107 | | |
| | 0 | 108 | | list.Add(GetUserView(parents, viewType, localizationKey, string.Empty, user, query.PresetViews)); |
| | | 109 | | } |
| | | 110 | | } |
| | | 111 | | |
| | 1 | 112 | | if (_config.Configuration.EnableFolderView) |
| | | 113 | | { |
| | 0 | 114 | | var name = _localizationManager.GetServerLocalizedString("Folders"); |
| | 0 | 115 | | list.Add(_libraryManager.GetNamedView(name, CollectionType.folders, string.Empty)); |
| | | 116 | | } |
| | | 117 | | |
| | 1 | 118 | | if (query.IncludeExternalContent) |
| | | 119 | | { |
| | 1 | 120 | | var channelResult = _channelManager.GetChannelsInternalAsync(new ChannelQuery |
| | 1 | 121 | | { |
| | 1 | 122 | | UserId = user.Id |
| | 1 | 123 | | }).GetAwaiter().GetResult(); |
| | | 124 | | |
| | 1 | 125 | | var channels = channelResult.Items; |
| | | 126 | | |
| | 1 | 127 | | list.AddRange(channels); |
| | | 128 | | |
| | 1 | 129 | | if (_liveTvManager.IsEnabledForUser(user)) |
| | | 130 | | { |
| | 0 | 131 | | list.Add(_liveTvManager.GetInternalLiveTvFolder(CancellationToken.None)); |
| | | 132 | | } |
| | | 133 | | } |
| | | 134 | | |
| | 1 | 135 | | if (!query.IncludeHidden) |
| | | 136 | | { |
| | 0 | 137 | | list = list.Where(i => !user.GetPreferenceValues<Guid>(PreferenceKind.MyMediaExcludes).Contains(i.Id)).T |
| | | 138 | | } |
| | | 139 | | |
| | 1 | 140 | | var sorted = _libraryManager.Sort(list, user, [ItemSortBy.SortName], SortOrder.Ascending).ToList(); |
| | 1 | 141 | | var orders = user.GetPreferenceValues<Guid>(PreferenceKind.OrderedViews); |
| | | 142 | | |
| | 1 | 143 | | return list |
| | 1 | 144 | | .OrderBy(i => |
| | 1 | 145 | | { |
| | 1 | 146 | | var index = Array.IndexOf(orders, i.Id); |
| | 1 | 147 | | if (index == -1 |
| | 1 | 148 | | && i is UserView view |
| | 1 | 149 | | && !view.DisplayParentId.IsEmpty()) |
| | 1 | 150 | | { |
| | 1 | 151 | | index = Array.IndexOf(orders, view.DisplayParentId); |
| | 1 | 152 | | } |
| | 1 | 153 | | |
| | 1 | 154 | | return index == -1 ? int.MaxValue : index; |
| | 1 | 155 | | }) |
| | 1 | 156 | | .ThenBy(sorted.IndexOf) |
| | 1 | 157 | | .ThenBy(i => i.SortName) |
| | 1 | 158 | | .ToArray(); |
| | | 159 | | } |
| | | 160 | | |
| | | 161 | | private bool HasVisibleItem(BaseItemKind itemKind, IReadOnlyList<Folder> folders, User user) |
| | | 162 | | { |
| | 1 | 163 | | var topParentIds = folders.SelectMany(GetTopParentIds).ToArray(); |
| | 1 | 164 | | if (topParentIds.Length == 0) |
| | | 165 | | { |
| | 0 | 166 | | return false; |
| | | 167 | | } |
| | | 168 | | |
| | 1 | 169 | | var items = _libraryManager.GetItemList(new InternalItemsQuery(user) |
| | 1 | 170 | | { |
| | 1 | 171 | | IncludeItemTypes = [itemKind], |
| | 1 | 172 | | TopParentIds = topParentIds, |
| | 1 | 173 | | GroupByPresentationUniqueKey = false, |
| | 1 | 174 | | DtoOptions = DtoOptions.StoredColumnsOnly |
| | 1 | 175 | | }); |
| | | 176 | | |
| | 1 | 177 | | return items.Any(item => item.IsVisible(user)); |
| | | 178 | | } |
| | | 179 | | |
| | | 180 | | private static IEnumerable<Guid> GetTopParentIds(Folder folder) |
| | | 181 | | { |
| | 1 | 182 | | return folder is CollectionFolder collectionFolder && collectionFolder.PhysicalFolderIds.Length > 0 |
| | 1 | 183 | | ? collectionFolder.PhysicalFolderIds |
| | 1 | 184 | | : [folder.Id]; |
| | | 185 | | } |
| | | 186 | | |
| | | 187 | | public UserView GetUserSubViewWithName(string name, Guid parentId, CollectionType? type, string sortName) |
| | | 188 | | { |
| | 0 | 189 | | var uniqueId = parentId + "subview" + type; |
| | | 190 | | |
| | 0 | 191 | | return _libraryManager.GetNamedView(name, parentId, type, sortName, uniqueId); |
| | | 192 | | } |
| | | 193 | | |
| | | 194 | | public UserView GetUserSubView(Guid parentId, CollectionType? type, string localizationKey, string sortName) |
| | | 195 | | { |
| | 0 | 196 | | var name = _localizationManager.GetServerLocalizedString(localizationKey); |
| | | 197 | | |
| | 0 | 198 | | return GetUserSubViewWithName(name, parentId, type, sortName); |
| | | 199 | | } |
| | | 200 | | |
| | | 201 | | private Folder GetUserView( |
| | | 202 | | List<ICollectionFolder> parents, |
| | | 203 | | CollectionType? viewType, |
| | | 204 | | string localizationKey, |
| | | 205 | | string sortName, |
| | | 206 | | User user, |
| | | 207 | | CollectionType?[] presetViews) |
| | | 208 | | { |
| | 0 | 209 | | if (parents.Count == 1 && parents.All(i => i.CollectionType == viewType)) |
| | | 210 | | { |
| | 0 | 211 | | if (!presetViews.Contains(viewType)) |
| | | 212 | | { |
| | 0 | 213 | | return (Folder)parents[0]; |
| | | 214 | | } |
| | | 215 | | |
| | 0 | 216 | | return GetUserView((Folder)parents[0], viewType, string.Empty); |
| | | 217 | | } |
| | | 218 | | |
| | 0 | 219 | | var name = _localizationManager.GetServerLocalizedString(localizationKey); |
| | 0 | 220 | | return _libraryManager.GetNamedView(user, name, viewType, sortName); |
| | | 221 | | } |
| | | 222 | | |
| | | 223 | | public UserView GetUserView(Folder parent, CollectionType? viewType, string sortName) |
| | | 224 | | { |
| | 0 | 225 | | return _libraryManager.GetShadowView(parent, viewType, sortName); |
| | | 226 | | } |
| | | 227 | | |
| | | 228 | | public List<Tuple<BaseItem, List<BaseItem>>> GetLatestItems(LatestItemsQuery request, DtoOptions options) |
| | | 229 | | { |
| | 0 | 230 | | var libraryItems = GetItemsForLatestItems(request.User, request, options); |
| | | 231 | | |
| | 0 | 232 | | var list = new List<Tuple<BaseItem, List<BaseItem>>>(); |
| | 0 | 233 | | var containerIndexMap = new Dictionary<Guid, int>(); |
| | 0 | 234 | | foreach (var item in libraryItems) |
| | | 235 | | { |
| | | 236 | | // Only grab the index container for media |
| | 0 | 237 | | var container = item.IsFolder || !request.GroupItems ? null : item.LatestItemsIndexContainer; |
| | | 238 | | |
| | 0 | 239 | | if (container is null) |
| | | 240 | | { |
| | 0 | 241 | | list.Add(new Tuple<BaseItem, List<BaseItem>>(null!, new List<BaseItem> { item })); |
| | | 242 | | } |
| | 0 | 243 | | else if (containerIndexMap.TryGetValue(container.Id, out var existingIndex)) |
| | | 244 | | { |
| | 0 | 245 | | list[existingIndex].Item2.Add(item); |
| | | 246 | | } |
| | | 247 | | else |
| | | 248 | | { |
| | 0 | 249 | | containerIndexMap[container.Id] = list.Count; |
| | 0 | 250 | | list.Add(new Tuple<BaseItem, List<BaseItem>>(container, new List<BaseItem> { item })); |
| | | 251 | | } |
| | | 252 | | |
| | 0 | 253 | | if (list.Count >= request.Limit) |
| | | 254 | | { |
| | 0 | 255 | | break; |
| | | 256 | | } |
| | | 257 | | } |
| | | 258 | | |
| | 0 | 259 | | return list; |
| | | 260 | | } |
| | | 261 | | |
| | | 262 | | private IReadOnlyList<BaseItem> GetItemsForLatestItems(User user, LatestItemsQuery request, DtoOptions options) |
| | | 263 | | { |
| | 0 | 264 | | var parentId = request.ParentId; |
| | | 265 | | |
| | 0 | 266 | | var includeItemTypes = request.IncludeItemTypes; |
| | 0 | 267 | | var limit = request.Limit ?? 10; |
| | | 268 | | |
| | 0 | 269 | | var parents = new List<BaseItem>(); |
| | | 270 | | |
| | 0 | 271 | | if (!parentId.IsEmpty()) |
| | | 272 | | { |
| | 0 | 273 | | var parentItem = _libraryManager.GetItemById(parentId); |
| | 0 | 274 | | if (parentItem is Channel) |
| | | 275 | | { |
| | 0 | 276 | | return _channelManager.GetLatestChannelItemsInternal( |
| | 0 | 277 | | new InternalItemsQuery(user) |
| | 0 | 278 | | { |
| | 0 | 279 | | ChannelIds = [parentId], |
| | 0 | 280 | | IsPlayed = request.IsPlayed, |
| | 0 | 281 | | StartIndex = request.StartIndex, |
| | 0 | 282 | | Limit = request.Limit, |
| | 0 | 283 | | IncludeItemTypes = request.IncludeItemTypes, |
| | 0 | 284 | | EnableTotalRecordCount = false |
| | 0 | 285 | | }, |
| | 0 | 286 | | CancellationToken.None).GetAwaiter().GetResult().Items; |
| | | 287 | | } |
| | | 288 | | |
| | 0 | 289 | | if (parentItem is Folder parent) |
| | | 290 | | { |
| | 0 | 291 | | parents.Add(parent); |
| | | 292 | | } |
| | | 293 | | } |
| | | 294 | | |
| | 0 | 295 | | var isPlayed = request.IsPlayed; |
| | | 296 | | |
| | 0 | 297 | | if (parents.OfType<ICollectionFolder>().Any(i => i.CollectionType == CollectionType.music)) |
| | | 298 | | { |
| | 0 | 299 | | isPlayed = null; |
| | | 300 | | } |
| | | 301 | | |
| | 0 | 302 | | if (parents.Count == 0) |
| | | 303 | | { |
| | 0 | 304 | | parents = _libraryManager.GetUserRootFolder().GetChildren(user, true) |
| | 0 | 305 | | .Where(i => i is Folder) |
| | 0 | 306 | | .Where(i => !user.GetPreferenceValues<Guid>(PreferenceKind.LatestItemExcludes) |
| | 0 | 307 | | .Contains(i.Id)) |
| | 0 | 308 | | .ToList(); |
| | | 309 | | } |
| | | 310 | | |
| | 0 | 311 | | if (parents.Count == 0) |
| | | 312 | | { |
| | 0 | 313 | | return Array.Empty<BaseItem>(); |
| | | 314 | | } |
| | | 315 | | |
| | 0 | 316 | | if (includeItemTypes.Length == 0) |
| | | 317 | | { |
| | | 318 | | // Handle situations with the grouping setting, e.g. movies showing up in tv, etc. |
| | | 319 | | // Thanks to mixed content libraries included in the UserView |
| | 0 | 320 | | var hasCollectionType = parents.OfType<UserView>().ToList(); |
| | 0 | 321 | | if (hasCollectionType.Count > 0) |
| | | 322 | | { |
| | 0 | 323 | | if (hasCollectionType.All(i => i.CollectionType == CollectionType.movies)) |
| | | 324 | | { |
| | 0 | 325 | | includeItemTypes = [BaseItemKind.Movie]; |
| | | 326 | | } |
| | 0 | 327 | | else if (hasCollectionType.All(i => i.CollectionType == CollectionType.tvshows)) |
| | | 328 | | { |
| | 0 | 329 | | includeItemTypes = [BaseItemKind.Episode]; |
| | | 330 | | } |
| | | 331 | | } |
| | | 332 | | } |
| | | 333 | | |
| | 0 | 334 | | MediaType[] mediaTypes = []; |
| | | 335 | | |
| | 0 | 336 | | if (includeItemTypes.Length == 0) |
| | | 337 | | { |
| | 0 | 338 | | HashSet<MediaType> tmpMediaTypes = []; |
| | 0 | 339 | | foreach (var parent in parents.OfType<ICollectionFolder>()) |
| | | 340 | | { |
| | 0 | 341 | | switch (parent.CollectionType) |
| | | 342 | | { |
| | | 343 | | case CollectionType.books: |
| | 0 | 344 | | tmpMediaTypes.Add(MediaType.Book); |
| | 0 | 345 | | tmpMediaTypes.Add(MediaType.Audio); |
| | 0 | 346 | | break; |
| | | 347 | | case CollectionType.music: |
| | 0 | 348 | | tmpMediaTypes.Add(MediaType.Audio); |
| | 0 | 349 | | break; |
| | | 350 | | case CollectionType.photos: |
| | 0 | 351 | | tmpMediaTypes.Add(MediaType.Photo); |
| | 0 | 352 | | tmpMediaTypes.Add(MediaType.Video); |
| | 0 | 353 | | break; |
| | | 354 | | case CollectionType.homevideos: |
| | 0 | 355 | | tmpMediaTypes.Add(MediaType.Photo); |
| | 0 | 356 | | tmpMediaTypes.Add(MediaType.Video); |
| | 0 | 357 | | break; |
| | | 358 | | default: |
| | 0 | 359 | | tmpMediaTypes.Add(MediaType.Video); |
| | | 360 | | break; |
| | | 361 | | } |
| | | 362 | | } |
| | | 363 | | |
| | 0 | 364 | | mediaTypes = tmpMediaTypes.ToArray(); |
| | | 365 | | } |
| | | 366 | | |
| | 0 | 367 | | var excludeItemTypes = includeItemTypes.Length == 0 && mediaTypes.Length == 0 |
| | 0 | 368 | | ? |
| | 0 | 369 | | [ |
| | 0 | 370 | | BaseItemKind.Person, |
| | 0 | 371 | | BaseItemKind.Studio, |
| | 0 | 372 | | BaseItemKind.Year, |
| | 0 | 373 | | BaseItemKind.MusicGenre, |
| | 0 | 374 | | BaseItemKind.Genre |
| | 0 | 375 | | ] |
| | 0 | 376 | | : Array.Empty<BaseItemKind>(); |
| | | 377 | | |
| | 0 | 378 | | var query = new InternalItemsQuery(user) |
| | 0 | 379 | | { |
| | 0 | 380 | | IncludeItemTypes = includeItemTypes, |
| | 0 | 381 | | OrderBy = |
| | 0 | 382 | | [ |
| | 0 | 383 | | (ItemSortBy.DateCreated, SortOrder.Descending), |
| | 0 | 384 | | (ItemSortBy.SortName, SortOrder.Descending), |
| | 0 | 385 | | (ItemSortBy.ProductionYear, SortOrder.Descending) |
| | 0 | 386 | | ], |
| | 0 | 387 | | IsFolder = includeItemTypes.Length == 0 ? false : null, |
| | 0 | 388 | | ExcludeItemTypes = excludeItemTypes, |
| | 0 | 389 | | IsVirtualItem = false, |
| | 0 | 390 | | Limit = limit * 2, |
| | 0 | 391 | | IsPlayed = isPlayed, |
| | 0 | 392 | | DtoOptions = options, |
| | 0 | 393 | | MediaTypes = mediaTypes |
| | 0 | 394 | | }; |
| | | 395 | | |
| | 0 | 396 | | if (request.GroupItems) |
| | | 397 | | { |
| | 0 | 398 | | var collectionType = parents |
| | 0 | 399 | | .Select(parent => parent switch |
| | 0 | 400 | | { |
| | 0 | 401 | | ICollectionFolder collectionFolder => collectionFolder.CollectionType, |
| | 0 | 402 | | UserView userView => userView.CollectionType, |
| | 0 | 403 | | _ => null |
| | 0 | 404 | | }) |
| | 0 | 405 | | .FirstOrDefault(type => type is not null); |
| | | 406 | | |
| | 0 | 407 | | if (collectionType == CollectionType.tvshows) |
| | | 408 | | { |
| | 0 | 409 | | query.Limit = limit; |
| | 0 | 410 | | return _libraryManager.GetLatestItemList(query, parents, CollectionType.tvshows); |
| | | 411 | | } |
| | | 412 | | |
| | 0 | 413 | | if (collectionType == CollectionType.music) |
| | | 414 | | { |
| | 0 | 415 | | query.Limit = limit; |
| | 0 | 416 | | return _libraryManager.GetLatestItemList(query, parents, CollectionType.music); |
| | | 417 | | } |
| | | 418 | | |
| | 0 | 419 | | if (collectionType == CollectionType.movies) |
| | | 420 | | { |
| | 0 | 421 | | query.Limit = limit; |
| | 0 | 422 | | return _libraryManager.GetLatestItemList(query, parents, CollectionType.movies); |
| | | 423 | | } |
| | | 424 | | |
| | 0 | 425 | | if (collectionType is null) |
| | | 426 | | { |
| | 0 | 427 | | query.Limit = limit; |
| | 0 | 428 | | return _libraryManager.GetLatestItemList(query, parents, CollectionType.unknown); |
| | | 429 | | } |
| | | 430 | | } |
| | | 431 | | |
| | 0 | 432 | | return _libraryManager.GetItemList(query, parents); |
| | | 433 | | } |
| | | 434 | | } |
| | | 435 | | } |