|
|
@@ -1,47 +1,45 @@
|
|
|
using MediaBrowser.Common.Extensions;
|
|
|
+using MediaBrowser.Controller;
|
|
|
+using MediaBrowser.Controller.Dto;
|
|
|
using MediaBrowser.Controller.Entities;
|
|
|
using MediaBrowser.Controller.Entities.Audio;
|
|
|
using MediaBrowser.Controller.Entities.Movies;
|
|
|
using MediaBrowser.Controller.Entities.TV;
|
|
|
using MediaBrowser.Controller.Library;
|
|
|
using MediaBrowser.Controller.Persistence;
|
|
|
+using MediaBrowser.Controller.Session;
|
|
|
using MediaBrowser.Model.Drawing;
|
|
|
using MediaBrowser.Model.Dto;
|
|
|
using MediaBrowser.Model.Entities;
|
|
|
using MediaBrowser.Model.Logging;
|
|
|
using MediaBrowser.Model.Querying;
|
|
|
+using MediaBrowser.Model.Session;
|
|
|
+using MoreLinq;
|
|
|
using System;
|
|
|
using System.Collections.Generic;
|
|
|
using System.IO;
|
|
|
using System.Linq;
|
|
|
using System.Threading.Tasks;
|
|
|
-using MoreLinq;
|
|
|
|
|
|
-namespace MediaBrowser.Controller.Dto
|
|
|
+namespace MediaBrowser.Server.Implementations.Dto
|
|
|
{
|
|
|
- /// <summary>
|
|
|
- /// Generates DTO's from domain entities
|
|
|
- /// </summary>
|
|
|
- public class DtoBuilder
|
|
|
+ public class DtoService : IDtoService
|
|
|
{
|
|
|
- /// <summary>
|
|
|
- /// The index folder delimeter
|
|
|
- /// </summary>
|
|
|
- const string IndexFolderDelimeter = "-index-";
|
|
|
-
|
|
|
private readonly ILogger _logger;
|
|
|
private readonly ILibraryManager _libraryManager;
|
|
|
+ private readonly IUserManager _userManager;
|
|
|
private readonly IUserDataRepository _userDataRepository;
|
|
|
private readonly IItemRepository _itemRepo;
|
|
|
|
|
|
- public DtoBuilder(ILogger logger, ILibraryManager libraryManager, IUserDataRepository userDataRepository, IItemRepository itemRepo)
|
|
|
+ public DtoService(ILogger logger, ILibraryManager libraryManager, IUserManager userManager, IUserDataRepository userDataRepository, IItemRepository itemRepo)
|
|
|
{
|
|
|
_logger = logger;
|
|
|
_libraryManager = libraryManager;
|
|
|
+ _userManager = userManager;
|
|
|
_userDataRepository = userDataRepository;
|
|
|
_itemRepo = itemRepo;
|
|
|
- }
|
|
|
-
|
|
|
+ }
|
|
|
+
|
|
|
/// <summary>
|
|
|
/// Converts a BaseItem to a DTOBaseItem
|
|
|
/// </summary>
|
|
|
@@ -81,7 +79,7 @@ namespace MediaBrowser.Controller.Dto
|
|
|
{
|
|
|
try
|
|
|
{
|
|
|
- await AttachPrimaryImageAspectRatio(dto, item, _logger).ConfigureAwait(false);
|
|
|
+ await AttachPrimaryImageAspectRatio(dto, item).ConfigureAwait(false);
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
@@ -140,7 +138,7 @@ namespace MediaBrowser.Controller.Dto
|
|
|
dto.ChildCount = folder.GetChildren(user, true).Count();
|
|
|
}
|
|
|
|
|
|
- SetSpecialCounts(folder, user, dto, _userDataRepository);
|
|
|
+ SetSpecialCounts(folder, user, dto);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
@@ -154,957 +152,1024 @@ namespace MediaBrowser.Controller.Dto
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// Attaches the primary image aspect ratio.
|
|
|
- /// </summary>
|
|
|
- /// <param name="dto">The dto.</param>
|
|
|
- /// <param name="item">The item.</param>
|
|
|
- /// <param name="logger">The _logger.</param>
|
|
|
- /// <returns>Task.</returns>
|
|
|
- internal static async Task AttachPrimaryImageAspectRatio(IItemDto dto, BaseItem item, ILogger logger)
|
|
|
+ public async Task<UserDto> GetUserDto(User user)
|
|
|
{
|
|
|
- var path = item.PrimaryImagePath;
|
|
|
-
|
|
|
- if (string.IsNullOrEmpty(path))
|
|
|
+ if (user == null)
|
|
|
{
|
|
|
- return;
|
|
|
+ throw new ArgumentNullException("user");
|
|
|
}
|
|
|
|
|
|
- var metaFileEntry = item.ResolveArgs.GetMetaFileByPath(path);
|
|
|
-
|
|
|
- // See if we can avoid a file system lookup by looking for the file in ResolveArgs
|
|
|
- var dateModified = metaFileEntry == null ? File.GetLastWriteTimeUtc(path) : metaFileEntry.LastWriteTimeUtc;
|
|
|
-
|
|
|
- ImageSize size;
|
|
|
-
|
|
|
- try
|
|
|
- {
|
|
|
- size = await Kernel.Instance.ImageManager.GetImageSize(path, dateModified).ConfigureAwait(false);
|
|
|
- }
|
|
|
- catch (FileNotFoundException)
|
|
|
- {
|
|
|
- logger.Error("Image file does not exist: {0}", path);
|
|
|
- return;
|
|
|
- }
|
|
|
- catch (Exception ex)
|
|
|
+ var dto = new UserDto
|
|
|
{
|
|
|
- logger.ErrorException("Failed to determine primary image aspect ratio for {0}", ex, path);
|
|
|
- return;
|
|
|
- }
|
|
|
+ Id = user.Id.ToString("N"),
|
|
|
+ Name = user.Name,
|
|
|
+ HasPassword = !String.IsNullOrEmpty(user.Password),
|
|
|
+ LastActivityDate = user.LastActivityDate,
|
|
|
+ LastLoginDate = user.LastLoginDate,
|
|
|
+ Configuration = user.Configuration
|
|
|
+ };
|
|
|
|
|
|
- dto.OriginalPrimaryImageAspectRatio = size.Width / size.Height;
|
|
|
+ var image = user.PrimaryImagePath;
|
|
|
|
|
|
- var supportedEnhancers = Kernel.Instance.ImageManager.ImageEnhancers.Where(i =>
|
|
|
+ if (!string.IsNullOrEmpty(image))
|
|
|
{
|
|
|
+ dto.PrimaryImageTag = Kernel.Instance.ImageManager.GetImageCacheTag(user, ImageType.Primary, image);
|
|
|
+
|
|
|
try
|
|
|
{
|
|
|
- return i.Supports(item, ImageType.Primary);
|
|
|
+ await AttachPrimaryImageAspectRatio(dto, user).ConfigureAwait(false);
|
|
|
}
|
|
|
catch (Exception ex)
|
|
|
{
|
|
|
- logger.ErrorException("Error in image enhancer: {0}", ex, i.GetType().Name);
|
|
|
-
|
|
|
- return false;
|
|
|
+ // Have to use a catch-all unfortunately because some .net image methods throw plain Exceptions
|
|
|
+ _logger.ErrorException("Error generating PrimaryImageAspectRatio for {0}", ex, user.Name);
|
|
|
}
|
|
|
+ }
|
|
|
|
|
|
- }).ToList();
|
|
|
+ return dto;
|
|
|
+ }
|
|
|
|
|
|
+ public SessionInfoDto GetSessionInfoDto(SessionInfo session)
|
|
|
+ {
|
|
|
+ var dto = new SessionInfoDto
|
|
|
+ {
|
|
|
+ Client = session.Client,
|
|
|
+ DeviceId = session.DeviceId,
|
|
|
+ DeviceName = session.DeviceName,
|
|
|
+ Id = session.Id.ToString("N"),
|
|
|
+ LastActivityDate = session.LastActivityDate,
|
|
|
+ NowPlayingPositionTicks = session.NowPlayingPositionTicks,
|
|
|
+ SupportsRemoteControl = session.SupportsRemoteControl,
|
|
|
+ IsPaused = session.IsPaused,
|
|
|
+ IsMuted = session.IsMuted,
|
|
|
+ NowViewingContext = session.NowViewingContext,
|
|
|
+ NowViewingItemId = session.NowViewingItemId,
|
|
|
+ NowViewingItemName = session.NowViewingItemName,
|
|
|
+ NowViewingItemType = session.NowViewingItemType,
|
|
|
+ ApplicationVersion = session.ApplicationVersion
|
|
|
+ };
|
|
|
|
|
|
- foreach (var enhancer in supportedEnhancers)
|
|
|
+ if (session.NowPlayingItem != null)
|
|
|
{
|
|
|
- try
|
|
|
- {
|
|
|
- size = enhancer.GetEnhancedImageSize(item, ImageType.Primary, 0, size);
|
|
|
- }
|
|
|
- catch (Exception ex)
|
|
|
- {
|
|
|
- logger.ErrorException("Error in image enhancer: {0}", ex, enhancer.GetType().Name);
|
|
|
- }
|
|
|
+ dto.NowPlayingItem = GetBaseItemInfo(session.NowPlayingItem);
|
|
|
}
|
|
|
|
|
|
- dto.PrimaryImageAspectRatio = size.Width / size.Height;
|
|
|
+ if (session.User != null)
|
|
|
+ {
|
|
|
+ dto.UserId = session.User.Id.ToString("N");
|
|
|
+ dto.UserName = session.User.Name;
|
|
|
+ }
|
|
|
+
|
|
|
+ return dto;
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
- /// Sets simple property values on a DTOBaseItem
|
|
|
+ /// Converts a BaseItem to a BaseItemInfo
|
|
|
/// </summary>
|
|
|
- /// <param name="dto">The dto.</param>
|
|
|
/// <param name="item">The item.</param>
|
|
|
- /// <param name="owner">The owner.</param>
|
|
|
- /// <param name="fields">The fields.</param>
|
|
|
- private void AttachBasicFields(BaseItemDto dto, BaseItem item, BaseItem owner, List<ItemFields> fields)
|
|
|
+ /// <returns>BaseItemInfo.</returns>
|
|
|
+ /// <exception cref="System.ArgumentNullException">item</exception>
|
|
|
+ public BaseItemInfo GetBaseItemInfo(BaseItem item)
|
|
|
{
|
|
|
- if (fields.Contains(ItemFields.DateCreated))
|
|
|
+ if (item == null)
|
|
|
{
|
|
|
- dto.DateCreated = item.DateCreated;
|
|
|
+ throw new ArgumentNullException("item");
|
|
|
}
|
|
|
|
|
|
- if (fields.Contains(ItemFields.OriginalRunTimeTicks))
|
|
|
+ var info = new BaseItemInfo
|
|
|
{
|
|
|
- dto.OriginalRunTimeTicks = item.OriginalRunTimeTicks;
|
|
|
- }
|
|
|
-
|
|
|
- dto.DisplayMediaType = item.DisplayMediaType;
|
|
|
+ Id = GetDtoId(item),
|
|
|
+ Name = item.Name,
|
|
|
+ MediaType = item.MediaType,
|
|
|
+ Type = item.GetType().Name,
|
|
|
+ IsFolder = item.IsFolder,
|
|
|
+ RunTimeTicks = item.RunTimeTicks
|
|
|
+ };
|
|
|
|
|
|
- if (fields.Contains(ItemFields.MetadataSettings))
|
|
|
- {
|
|
|
- dto.LockedFields = item.LockedFields;
|
|
|
- dto.EnableInternetProviders = !item.DontFetchMeta;
|
|
|
- }
|
|
|
+ var imagePath = item.PrimaryImagePath;
|
|
|
|
|
|
- if (fields.Contains(ItemFields.Budget))
|
|
|
+ if (!string.IsNullOrEmpty(imagePath))
|
|
|
{
|
|
|
- dto.Budget = item.Budget;
|
|
|
+ try
|
|
|
+ {
|
|
|
+ info.PrimaryImageTag = Kernel.Instance.ImageManager.GetImageCacheTag(item, ImageType.Primary, imagePath);
|
|
|
+ }
|
|
|
+ catch (IOException)
|
|
|
+ {
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
- if (fields.Contains(ItemFields.Revenue))
|
|
|
- {
|
|
|
- dto.Revenue = item.Revenue;
|
|
|
- }
|
|
|
+ return info;
|
|
|
+ }
|
|
|
|
|
|
- dto.EndDate = item.EndDate;
|
|
|
+ const string IndexFolderDelimeter = "-index-";
|
|
|
|
|
|
- if (fields.Contains(ItemFields.HomePageUrl))
|
|
|
+ /// <summary>
|
|
|
+ /// Gets client-side Id of a server-side BaseItem
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="item">The item.</param>
|
|
|
+ /// <returns>System.String.</returns>
|
|
|
+ /// <exception cref="System.ArgumentNullException">item</exception>
|
|
|
+ public string GetDtoId(BaseItem item)
|
|
|
+ {
|
|
|
+ if (item == null)
|
|
|
{
|
|
|
- dto.HomePageUrl = item.HomePageUrl;
|
|
|
+ throw new ArgumentNullException("item");
|
|
|
}
|
|
|
|
|
|
- if (fields.Contains(ItemFields.Tags))
|
|
|
- {
|
|
|
- dto.Tags = item.Tags;
|
|
|
- }
|
|
|
+ var indexFolder = item as IndexFolder;
|
|
|
|
|
|
- if (fields.Contains(ItemFields.ProductionLocations))
|
|
|
+ if (indexFolder != null)
|
|
|
{
|
|
|
- dto.ProductionLocations = item.ProductionLocations;
|
|
|
+ return GetDtoId(indexFolder.Parent) + IndexFolderDelimeter + (indexFolder.IndexName ?? string.Empty) + IndexFolderDelimeter + indexFolder.Id;
|
|
|
}
|
|
|
|
|
|
- dto.AspectRatio = item.AspectRatio;
|
|
|
-
|
|
|
- dto.BackdropImageTags = GetBackdropImageTags(item);
|
|
|
- dto.ScreenshotImageTags = GetScreenshotImageTags(item);
|
|
|
+ return item.Id.ToString("N");
|
|
|
+ }
|
|
|
|
|
|
- if (fields.Contains(ItemFields.Genres))
|
|
|
+ /// <summary>
|
|
|
+ /// Converts a UserItemData to a DTOUserItemData
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="data">The data.</param>
|
|
|
+ /// <returns>DtoUserItemData.</returns>
|
|
|
+ /// <exception cref="System.ArgumentNullException"></exception>
|
|
|
+ public UserItemDataDto GetUserItemDataDto(UserItemData data)
|
|
|
+ {
|
|
|
+ if (data == null)
|
|
|
{
|
|
|
- dto.Genres = item.Genres;
|
|
|
+ throw new ArgumentNullException("data");
|
|
|
}
|
|
|
|
|
|
- dto.ImageTags = new Dictionary<ImageType, Guid>();
|
|
|
-
|
|
|
- foreach (var image in item.Images)
|
|
|
+ return new UserItemDataDto
|
|
|
{
|
|
|
- var type = image.Key;
|
|
|
+ IsFavorite = data.IsFavorite,
|
|
|
+ Likes = data.Likes,
|
|
|
+ PlaybackPositionTicks = data.PlaybackPositionTicks,
|
|
|
+ PlayCount = data.PlayCount,
|
|
|
+ Rating = data.Rating,
|
|
|
+ Played = data.Played,
|
|
|
+ LastPlayedDate = data.LastPlayedDate
|
|
|
+ };
|
|
|
+ }
|
|
|
+ private void SetBookProperties(BaseItemDto dto, Book item)
|
|
|
+ {
|
|
|
+ dto.SeriesName = item.SeriesName;
|
|
|
+ }
|
|
|
|
|
|
- var tag = GetImageCacheTag(item, type, image.Value);
|
|
|
+ private void SetMusicVideoProperties(BaseItemDto dto, MusicVideo item)
|
|
|
+ {
|
|
|
+ if (!string.IsNullOrEmpty(item.Album))
|
|
|
+ {
|
|
|
+ var parentAlbum = _libraryManager.RootFolder
|
|
|
+ .RecursiveChildren
|
|
|
+ .OfType<MusicAlbum>()
|
|
|
+ .FirstOrDefault(i => string.Equals(i.Name, item.Album, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
|
- if (tag.HasValue)
|
|
|
+ if (parentAlbum != null)
|
|
|
{
|
|
|
- dto.ImageTags[type] = tag.Value;
|
|
|
+ dto.AlbumId = GetDtoId(parentAlbum);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- dto.Id = GetClientItemId(item);
|
|
|
- dto.IndexNumber = item.IndexNumber;
|
|
|
- dto.IsFolder = item.IsFolder;
|
|
|
- dto.Language = item.Language;
|
|
|
- dto.MediaType = item.MediaType;
|
|
|
- dto.LocationType = item.LocationType;
|
|
|
- dto.CriticRating = item.CriticRating;
|
|
|
-
|
|
|
- if (fields.Contains(ItemFields.CriticRatingSummary))
|
|
|
- {
|
|
|
- dto.CriticRatingSummary = item.CriticRatingSummary;
|
|
|
- }
|
|
|
-
|
|
|
- var localTrailerCount = item.LocalTrailerIds.Count;
|
|
|
+ dto.Album = item.Album;
|
|
|
+ dto.Artists = string.IsNullOrEmpty(item.Artist) ? new string[] { } : new[] { item.Artist };
|
|
|
+ }
|
|
|
|
|
|
- if (localTrailerCount > 0)
|
|
|
- {
|
|
|
- dto.LocalTrailerCount = localTrailerCount;
|
|
|
- }
|
|
|
+ private void SetGameProperties(BaseItemDto dto, Game item)
|
|
|
+ {
|
|
|
+ dto.Players = item.PlayersSupported;
|
|
|
+ dto.GameSystem = item.GameSystem;
|
|
|
+ }
|
|
|
|
|
|
- dto.Name = item.Name;
|
|
|
- dto.OfficialRating = item.OfficialRating;
|
|
|
+ /// <summary>
|
|
|
+ /// Gets the backdrop image tags.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="item">The item.</param>
|
|
|
+ /// <returns>List{System.String}.</returns>
|
|
|
+ private List<Guid> GetBackdropImageTags(BaseItem item)
|
|
|
+ {
|
|
|
+ return item.BackdropImagePaths
|
|
|
+ .Select(p => GetImageCacheTag(item, ImageType.Backdrop, p))
|
|
|
+ .Where(i => i.HasValue)
|
|
|
+ .Select(i => i.Value)
|
|
|
+ .ToList();
|
|
|
+ }
|
|
|
|
|
|
- var hasOverview = fields.Contains(ItemFields.Overview);
|
|
|
- var hasHtmlOverview = fields.Contains(ItemFields.OverviewHtml);
|
|
|
+ /// <summary>
|
|
|
+ /// Gets the screenshot image tags.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="item">The item.</param>
|
|
|
+ /// <returns>List{Guid}.</returns>
|
|
|
+ private List<Guid> GetScreenshotImageTags(BaseItem item)
|
|
|
+ {
|
|
|
+ return item.ScreenshotImagePaths
|
|
|
+ .Select(p => GetImageCacheTag(item, ImageType.Screenshot, p))
|
|
|
+ .Where(i => i.HasValue)
|
|
|
+ .Select(i => i.Value)
|
|
|
+ .ToList();
|
|
|
+ }
|
|
|
|
|
|
- if (hasOverview || hasHtmlOverview)
|
|
|
+ private Guid? GetImageCacheTag(BaseItem item, ImageType type, string path)
|
|
|
+ {
|
|
|
+ try
|
|
|
{
|
|
|
- var strippedOverview = string.IsNullOrEmpty(item.Overview) ? item.Overview : item.Overview.StripHtml();
|
|
|
-
|
|
|
- if (hasOverview)
|
|
|
- {
|
|
|
- dto.Overview = strippedOverview;
|
|
|
- }
|
|
|
-
|
|
|
- // Only supply the html version if there was actually html content
|
|
|
- if (hasHtmlOverview)
|
|
|
- {
|
|
|
- dto.OverviewHtml = item.Overview;
|
|
|
- }
|
|
|
+ return Kernel.Instance.ImageManager.GetImageCacheTag(item, type, path);
|
|
|
}
|
|
|
-
|
|
|
- // If there are no backdrops, indicate what parent has them in case the Ui wants to allow inheritance
|
|
|
- if (dto.BackdropImageTags.Count == 0)
|
|
|
+ catch (IOException ex)
|
|
|
{
|
|
|
- var parentWithBackdrop = GetParentBackdropItem(item, owner);
|
|
|
-
|
|
|
- if (parentWithBackdrop != null)
|
|
|
- {
|
|
|
- dto.ParentBackdropItemId = GetClientItemId(parentWithBackdrop);
|
|
|
- dto.ParentBackdropImageTags = GetBackdropImageTags(parentWithBackdrop);
|
|
|
- }
|
|
|
+ _logger.ErrorException("Error getting {0} image info for {1}", ex, type, path);
|
|
|
+ return null;
|
|
|
}
|
|
|
+ } /// <summary>
|
|
|
+ /// Attaches People DTO's to a DTOBaseItem
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="dto">The dto.</param>
|
|
|
+ /// <param name="item">The item.</param>
|
|
|
+ /// <returns>Task.</returns>
|
|
|
+ private async Task AttachPeople(BaseItemDto dto, BaseItem item)
|
|
|
+ {
|
|
|
+ // Ordering by person type to ensure actors and artists are at the front.
|
|
|
+ // This is taking advantage of the fact that they both begin with A
|
|
|
+ // This should be improved in the future
|
|
|
+ var people = item.People.OrderBy(i => i.Type).ToList();
|
|
|
|
|
|
- if (item.Parent != null && fields.Contains(ItemFields.ParentId))
|
|
|
- {
|
|
|
- dto.ParentId = GetClientItemId(item.Parent);
|
|
|
- }
|
|
|
+ // Attach People by transforming them into BaseItemPerson (DTO)
|
|
|
+ dto.People = new BaseItemPerson[people.Count];
|
|
|
|
|
|
- dto.ParentIndexNumber = item.ParentIndexNumber;
|
|
|
+ var entities = await Task.WhenAll(people.Select(p => p.Name)
|
|
|
+ .Distinct(StringComparer.OrdinalIgnoreCase).Select(c =>
|
|
|
+ Task.Run(async () =>
|
|
|
+ {
|
|
|
+ try
|
|
|
+ {
|
|
|
+ return await _libraryManager.GetPerson(c).ConfigureAwait(false);
|
|
|
+ }
|
|
|
+ catch (IOException ex)
|
|
|
+ {
|
|
|
+ _logger.ErrorException("Error getting person {0}", ex, c);
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ })
|
|
|
|
|
|
- // If there is no logo, indicate what parent has one in case the Ui wants to allow inheritance
|
|
|
- if (!dto.HasLogo)
|
|
|
+ )).ConfigureAwait(false);
|
|
|
+
|
|
|
+ var dictionary = entities.Where(i => i != null)
|
|
|
+ .DistinctBy(i => i.Name)
|
|
|
+ .ToDictionary(i => i.Name, StringComparer.OrdinalIgnoreCase);
|
|
|
+
|
|
|
+ for (var i = 0; i < people.Count; i++)
|
|
|
{
|
|
|
- var parentWithLogo = GetParentImageItem(item, ImageType.Logo, owner);
|
|
|
+ var person = people[i];
|
|
|
|
|
|
- if (parentWithLogo != null)
|
|
|
+ var baseItemPerson = new BaseItemPerson
|
|
|
{
|
|
|
- dto.ParentLogoItemId = GetClientItemId(parentWithLogo);
|
|
|
+ Name = person.Name,
|
|
|
+ Role = person.Role,
|
|
|
+ Type = person.Type
|
|
|
+ };
|
|
|
|
|
|
- dto.ParentLogoImageTag = GetImageCacheTag(parentWithLogo, ImageType.Logo, parentWithLogo.GetImage(ImageType.Logo));
|
|
|
+ Person entity;
|
|
|
+
|
|
|
+ if (dictionary.TryGetValue(person.Name, out entity))
|
|
|
+ {
|
|
|
+ var primaryImagePath = entity.PrimaryImagePath;
|
|
|
+
|
|
|
+ if (!string.IsNullOrEmpty(primaryImagePath))
|
|
|
+ {
|
|
|
+ baseItemPerson.PrimaryImageTag = GetImageCacheTag(entity, ImageType.Primary, primaryImagePath);
|
|
|
+ }
|
|
|
}
|
|
|
+
|
|
|
+ dto.People[i] = baseItemPerson;
|
|
|
}
|
|
|
+ }
|
|
|
|
|
|
- // If there is no art, indicate what parent has one in case the Ui wants to allow inheritance
|
|
|
- if (!dto.HasArtImage)
|
|
|
+ /// <summary>
|
|
|
+ /// Attaches the studios.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="dto">The dto.</param>
|
|
|
+ /// <param name="item">The item.</param>
|
|
|
+ /// <returns>Task.</returns>
|
|
|
+ private async Task AttachStudios(BaseItemDto dto, BaseItem item)
|
|
|
+ {
|
|
|
+ var studios = item.Studios.ToList();
|
|
|
+
|
|
|
+ dto.Studios = new StudioDto[studios.Count];
|
|
|
+
|
|
|
+ var entities = await Task.WhenAll(studios.Distinct(StringComparer.OrdinalIgnoreCase).Select(c =>
|
|
|
+
|
|
|
+ Task.Run(async () =>
|
|
|
+ {
|
|
|
+ try
|
|
|
+ {
|
|
|
+ return await _libraryManager.GetStudio(c).ConfigureAwait(false);
|
|
|
+ }
|
|
|
+ catch (IOException ex)
|
|
|
+ {
|
|
|
+ _logger.ErrorException("Error getting studio {0}", ex, c);
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+ })
|
|
|
+
|
|
|
+ )).ConfigureAwait(false);
|
|
|
+
|
|
|
+ var dictionary = entities
|
|
|
+ .Where(i => i != null)
|
|
|
+ .ToDictionary(i => i.Name, StringComparer.OrdinalIgnoreCase);
|
|
|
+
|
|
|
+ for (var i = 0; i < studios.Count; i++)
|
|
|
{
|
|
|
- var parentWithImage = GetParentImageItem(item, ImageType.Art, owner);
|
|
|
+ var studio = studios[i];
|
|
|
|
|
|
- if (parentWithImage != null)
|
|
|
+ var studioDto = new StudioDto
|
|
|
{
|
|
|
- dto.ParentArtItemId = GetClientItemId(parentWithImage);
|
|
|
+ Name = studio
|
|
|
+ };
|
|
|
|
|
|
- dto.ParentArtImageTag = GetImageCacheTag(parentWithImage, ImageType.Art, parentWithImage.GetImage(ImageType.Art));
|
|
|
+ Studio entity;
|
|
|
+
|
|
|
+ if (dictionary.TryGetValue(studio, out entity))
|
|
|
+ {
|
|
|
+ var primaryImagePath = entity.PrimaryImagePath;
|
|
|
+
|
|
|
+ if (!string.IsNullOrEmpty(primaryImagePath))
|
|
|
+ {
|
|
|
+ studioDto.PrimaryImageTag = GetImageCacheTag(entity, ImageType.Primary, primaryImagePath);
|
|
|
+ }
|
|
|
}
|
|
|
- }
|
|
|
|
|
|
- if (fields.Contains(ItemFields.Path))
|
|
|
- {
|
|
|
- dto.Path = item.Path;
|
|
|
+ dto.Studios[i] = studioDto;
|
|
|
}
|
|
|
+ }
|
|
|
|
|
|
- dto.PremiereDate = item.PremiereDate;
|
|
|
- dto.ProductionYear = item.ProductionYear;
|
|
|
+ /// <summary>
|
|
|
+ /// If an item does not any backdrops, this can be used to find the first parent that does have one
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="item">The item.</param>
|
|
|
+ /// <param name="owner">The owner.</param>
|
|
|
+ /// <returns>BaseItem.</returns>
|
|
|
+ private BaseItem GetParentBackdropItem(BaseItem item, BaseItem owner)
|
|
|
+ {
|
|
|
+ var parent = item.Parent ?? owner;
|
|
|
|
|
|
- if (fields.Contains(ItemFields.ProviderIds))
|
|
|
+ while (parent != null)
|
|
|
{
|
|
|
- dto.ProviderIds = item.ProviderIds;
|
|
|
+ if (parent.BackdropImagePaths != null && parent.BackdropImagePaths.Count > 0)
|
|
|
+ {
|
|
|
+ return parent;
|
|
|
+ }
|
|
|
+
|
|
|
+ parent = parent.Parent;
|
|
|
}
|
|
|
|
|
|
- dto.RunTimeTicks = item.RunTimeTicks;
|
|
|
+ return null;
|
|
|
+ }
|
|
|
|
|
|
- if (fields.Contains(ItemFields.SortName))
|
|
|
+ /// <summary>
|
|
|
+ /// If an item does not have a logo, this can be used to find the first parent that does have one
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="item">The item.</param>
|
|
|
+ /// <param name="type">The type.</param>
|
|
|
+ /// <param name="owner">The owner.</param>
|
|
|
+ /// <returns>BaseItem.</returns>
|
|
|
+ private BaseItem GetParentImageItem(BaseItem item, ImageType type, BaseItem owner)
|
|
|
+ {
|
|
|
+ var parent = item.Parent ?? owner;
|
|
|
+
|
|
|
+ while (parent != null)
|
|
|
{
|
|
|
- dto.SortName = item.SortName;
|
|
|
+ if (parent.HasImage(type))
|
|
|
+ {
|
|
|
+ return parent;
|
|
|
+ }
|
|
|
+
|
|
|
+ parent = parent.Parent;
|
|
|
}
|
|
|
|
|
|
- if (fields.Contains(ItemFields.CustomRating))
|
|
|
+ return null;
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Gets the chapter info dto.
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="chapterInfo">The chapter info.</param>
|
|
|
+ /// <param name="item">The item.</param>
|
|
|
+ /// <returns>ChapterInfoDto.</returns>
|
|
|
+ private ChapterInfoDto GetChapterInfoDto(ChapterInfo chapterInfo, BaseItem item)
|
|
|
+ {
|
|
|
+ var dto = new ChapterInfoDto
|
|
|
{
|
|
|
- dto.CustomRating = item.CustomRating;
|
|
|
- }
|
|
|
+ Name = chapterInfo.Name,
|
|
|
+ StartPositionTicks = chapterInfo.StartPositionTicks
|
|
|
+ };
|
|
|
|
|
|
- if (fields.Contains(ItemFields.Taglines))
|
|
|
+ if (!string.IsNullOrEmpty(chapterInfo.ImagePath))
|
|
|
{
|
|
|
- dto.Taglines = item.Taglines;
|
|
|
+ dto.ImageTag = GetImageCacheTag(item, ImageType.Chapter, chapterInfo.ImagePath);
|
|
|
}
|
|
|
|
|
|
- if (fields.Contains(ItemFields.RemoteTrailers))
|
|
|
+ return dto;
|
|
|
+ }
|
|
|
+
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Gets a BaseItem based upon it's client-side item id
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="id">The id.</param>
|
|
|
+ /// <param name="userId">The user id.</param>
|
|
|
+ /// <returns>BaseItem.</returns>
|
|
|
+ public BaseItem GetItemByDtoId(string id, Guid? userId = null)
|
|
|
+ {
|
|
|
+ if (string.IsNullOrEmpty(id))
|
|
|
{
|
|
|
- dto.RemoteTrailers = item.RemoteTrailers;
|
|
|
+ throw new ArgumentNullException("id");
|
|
|
}
|
|
|
|
|
|
- dto.Type = item.GetType().Name;
|
|
|
- dto.CommunityRating = item.CommunityRating;
|
|
|
+ // If the item is an indexed folder we have to do a special routine to get it
|
|
|
+ var isIndexFolder = id.IndexOf(IndexFolderDelimeter, StringComparison.OrdinalIgnoreCase) != -1;
|
|
|
|
|
|
- if (item.IsFolder)
|
|
|
+ if (isIndexFolder)
|
|
|
{
|
|
|
- var folder = (Folder)item;
|
|
|
-
|
|
|
- if (fields.Contains(ItemFields.IndexOptions))
|
|
|
+ if (userId.HasValue)
|
|
|
{
|
|
|
- dto.IndexOptions = folder.IndexByOptionStrings.ToArray();
|
|
|
+ return GetIndexFolder(id, userId.Value);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- // Add audio info
|
|
|
- var audio = item as Audio;
|
|
|
- if (audio != null)
|
|
|
- {
|
|
|
- dto.Album = audio.Album;
|
|
|
- dto.AlbumArtist = audio.AlbumArtist;
|
|
|
- dto.Artists = new[] { audio.Artist };
|
|
|
+ BaseItem item = null;
|
|
|
|
|
|
- var albumParent = audio.FindParent<MusicAlbum>();
|
|
|
+ if (userId.HasValue || !isIndexFolder)
|
|
|
+ {
|
|
|
+ item = _libraryManager.GetItemById(new Guid(id));
|
|
|
+ }
|
|
|
|
|
|
- if (albumParent != null)
|
|
|
+ // If we still don't find it, look within individual user views
|
|
|
+ if (item == null && !userId.HasValue && isIndexFolder)
|
|
|
+ {
|
|
|
+ foreach (var user in _userManager.Users)
|
|
|
{
|
|
|
- dto.AlbumId = GetClientItemId(albumParent);
|
|
|
-
|
|
|
- var imagePath = albumParent.PrimaryImagePath;
|
|
|
+ item = GetItemByDtoId(id, user.Id);
|
|
|
|
|
|
- if (!string.IsNullOrEmpty(imagePath))
|
|
|
+ if (item != null)
|
|
|
{
|
|
|
- dto.AlbumPrimaryImageTag = GetImageCacheTag(albumParent, ImageType.Primary, imagePath);
|
|
|
+ break;
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- var album = item as MusicAlbum;
|
|
|
+ return item;
|
|
|
+ }
|
|
|
|
|
|
- if (album != null)
|
|
|
- {
|
|
|
- var songs = album.RecursiveChildren.OfType<Audio>().ToList();
|
|
|
+ /// <summary>
|
|
|
+ /// Finds an index folder based on an Id and userId
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="id">The id.</param>
|
|
|
+ /// <param name="userId">The user id.</param>
|
|
|
+ /// <returns>BaseItem.</returns>
|
|
|
+ private BaseItem GetIndexFolder(string id, Guid userId)
|
|
|
+ {
|
|
|
+ var user = _userManager.GetUserById(userId);
|
|
|
|
|
|
- dto.AlbumArtist = songs.Select(i => i.AlbumArtist).FirstOrDefault(i => !string.IsNullOrEmpty(i));
|
|
|
+ var stringSeparators = new[] { IndexFolderDelimeter };
|
|
|
|
|
|
- dto.Artists =
|
|
|
- songs.Select(i => i.Artist ?? string.Empty)
|
|
|
- .Where(i => !string.IsNullOrEmpty(i))
|
|
|
- .Distinct(StringComparer.OrdinalIgnoreCase)
|
|
|
- .ToArray();
|
|
|
- }
|
|
|
+ // Split using the delimeter
|
|
|
+ var values = id.Split(stringSeparators, StringSplitOptions.None).ToList();
|
|
|
|
|
|
- // Add video info
|
|
|
- var video = item as Video;
|
|
|
- if (video != null)
|
|
|
- {
|
|
|
- dto.VideoType = video.VideoType;
|
|
|
- dto.Video3DFormat = video.Video3DFormat;
|
|
|
- dto.IsoType = video.IsoType;
|
|
|
- dto.MainFeaturePlaylistName = video.MainFeaturePlaylistName;
|
|
|
+ // Get the top folder normally using the first id
|
|
|
+ var folder = GetItemByDtoId(values[0], userId) as Folder;
|
|
|
|
|
|
- dto.PartCount = video.AdditionalPartIds.Count + 1;
|
|
|
+ values.RemoveAt(0);
|
|
|
|
|
|
- if (fields.Contains(ItemFields.Chapters))
|
|
|
- {
|
|
|
- dto.Chapters = _itemRepo.GetChapters(video.Id).Select(c => GetChapterInfoDto(c, item)).ToList();
|
|
|
- }
|
|
|
- }
|
|
|
+ // Get indexed folders using the remaining values in the id string
|
|
|
+ return GetIndexFolder(values, folder, user);
|
|
|
+ }
|
|
|
|
|
|
- if (fields.Contains(ItemFields.MediaStreams))
|
|
|
- {
|
|
|
- // Add VideoInfo
|
|
|
- var iHasMediaStreams = item as IHasMediaStreams;
|
|
|
+ /// <summary>
|
|
|
+ /// Gets indexed folders based on a list of index names and folder id's
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="values">The values.</param>
|
|
|
+ /// <param name="parentFolder">The parent folder.</param>
|
|
|
+ /// <param name="user">The user.</param>
|
|
|
+ /// <returns>BaseItem.</returns>
|
|
|
+ private BaseItem GetIndexFolder(List<string> values, Folder parentFolder, User user)
|
|
|
+ {
|
|
|
+ // The index name is first
|
|
|
+ var indexBy = values[0];
|
|
|
|
|
|
- if (iHasMediaStreams != null)
|
|
|
- {
|
|
|
- dto.MediaStreams = iHasMediaStreams.MediaStreams;
|
|
|
- }
|
|
|
- }
|
|
|
+ // The index folder id is next
|
|
|
+ var indexFolderId = new Guid(values[1]);
|
|
|
|
|
|
- // Add MovieInfo
|
|
|
- var movie = item as Movie;
|
|
|
+ // Remove them from the lst
|
|
|
+ values.RemoveRange(0, 2);
|
|
|
|
|
|
- if (movie != null)
|
|
|
- {
|
|
|
- var specialFeatureCount = movie.SpecialFeatureIds.Count;
|
|
|
+ // Get the IndexFolder
|
|
|
+ var indexFolder = parentFolder.GetChildren(user, false, indexBy).FirstOrDefault(i => i.Id == indexFolderId) as Folder;
|
|
|
|
|
|
- if (specialFeatureCount > 0)
|
|
|
- {
|
|
|
- dto.SpecialFeatureCount = specialFeatureCount;
|
|
|
- }
|
|
|
+ // Nested index folder
|
|
|
+ if (values.Count > 0)
|
|
|
+ {
|
|
|
+ return GetIndexFolder(values, indexFolder, user);
|
|
|
}
|
|
|
|
|
|
- // Add EpisodeInfo
|
|
|
- var episode = item as Episode;
|
|
|
+ return indexFolder;
|
|
|
+ }
|
|
|
|
|
|
- if (episode != null)
|
|
|
+ /// <summary>
|
|
|
+ /// Sets simple property values on a DTOBaseItem
|
|
|
+ /// </summary>
|
|
|
+ /// <param name="dto">The dto.</param>
|
|
|
+ /// <param name="item">The item.</param>
|
|
|
+ /// <param name="owner">The owner.</param>
|
|
|
+ /// <param name="fields">The fields.</param>
|
|
|
+ private void AttachBasicFields(BaseItemDto dto, BaseItem item, BaseItem owner, List<ItemFields> fields)
|
|
|
+ {
|
|
|
+ if (fields.Contains(ItemFields.DateCreated))
|
|
|
{
|
|
|
- dto.IndexNumberEnd = episode.IndexNumberEnd;
|
|
|
+ dto.DateCreated = item.DateCreated;
|
|
|
}
|
|
|
|
|
|
- // Add SeriesInfo
|
|
|
- var series = item as Series;
|
|
|
-
|
|
|
- if (series != null)
|
|
|
+ if (fields.Contains(ItemFields.OriginalRunTimeTicks))
|
|
|
{
|
|
|
- dto.AirDays = series.AirDays;
|
|
|
- dto.AirTime = series.AirTime;
|
|
|
- dto.Status = series.Status;
|
|
|
+ dto.OriginalRunTimeTicks = item.OriginalRunTimeTicks;
|
|
|
+ }
|
|
|
|
|
|
- dto.SpecialFeatureCount = series.SpecialFeatureIds.Count;
|
|
|
+ dto.DisplayMediaType = item.DisplayMediaType;
|
|
|
|
|
|
- dto.SeasonCount = series.SeasonCount;
|
|
|
+ if (fields.Contains(ItemFields.MetadataSettings))
|
|
|
+ {
|
|
|
+ dto.LockedFields = item.LockedFields;
|
|
|
+ dto.EnableInternetProviders = !item.DontFetchMeta;
|
|
|
}
|
|
|
|
|
|
- if (episode != null)
|
|
|
+ if (fields.Contains(ItemFields.Budget))
|
|
|
{
|
|
|
- series = item.FindParent<Series>();
|
|
|
-
|
|
|
- dto.SeriesId = GetClientItemId(series);
|
|
|
- dto.SeriesName = series.Name;
|
|
|
+ dto.Budget = item.Budget;
|
|
|
}
|
|
|
|
|
|
- // Add SeasonInfo
|
|
|
- var season = item as Season;
|
|
|
-
|
|
|
- if (season != null)
|
|
|
+ if (fields.Contains(ItemFields.Revenue))
|
|
|
{
|
|
|
- series = item.FindParent<Series>();
|
|
|
-
|
|
|
- dto.SeriesId = GetClientItemId(series);
|
|
|
- dto.SeriesName = series.Name;
|
|
|
+ dto.Revenue = item.Revenue;
|
|
|
}
|
|
|
|
|
|
- var game = item as Game;
|
|
|
+ dto.EndDate = item.EndDate;
|
|
|
|
|
|
- if (game != null)
|
|
|
+ if (fields.Contains(ItemFields.HomePageUrl))
|
|
|
{
|
|
|
- SetGameProperties(dto, game);
|
|
|
+ dto.HomePageUrl = item.HomePageUrl;
|
|
|
}
|
|
|
|
|
|
- var musicVideo = item as MusicVideo;
|
|
|
+ if (fields.Contains(ItemFields.Tags))
|
|
|
+ {
|
|
|
+ dto.Tags = item.Tags;
|
|
|
+ }
|
|
|
|
|
|
- if (musicVideo != null)
|
|
|
+ if (fields.Contains(ItemFields.ProductionLocations))
|
|
|
{
|
|
|
- SetMusicVideoProperties(dto, musicVideo);
|
|
|
+ dto.ProductionLocations = item.ProductionLocations;
|
|
|
}
|
|
|
|
|
|
- var book = item as Book;
|
|
|
+ dto.AspectRatio = item.AspectRatio;
|
|
|
|
|
|
- if (book != null)
|
|
|
+ dto.BackdropImageTags = GetBackdropImageTags(item);
|
|
|
+ dto.ScreenshotImageTags = GetScreenshotImageTags(item);
|
|
|
+
|
|
|
+ if (fields.Contains(ItemFields.Genres))
|
|
|
{
|
|
|
- SetBookProperties(dto, book);
|
|
|
+ dto.Genres = item.Genres;
|
|
|
}
|
|
|
- }
|
|
|
|
|
|
- private void SetBookProperties(BaseItemDto dto, Book item)
|
|
|
- {
|
|
|
- dto.SeriesName = item.SeriesName;
|
|
|
- }
|
|
|
+ dto.ImageTags = new Dictionary<ImageType, Guid>();
|
|
|
|
|
|
- private void SetMusicVideoProperties(BaseItemDto dto, MusicVideo item)
|
|
|
- {
|
|
|
- if (!string.IsNullOrEmpty(item.Album))
|
|
|
+ foreach (var image in item.Images)
|
|
|
{
|
|
|
- var parentAlbum = _libraryManager.RootFolder
|
|
|
- .RecursiveChildren
|
|
|
- .OfType<MusicAlbum>()
|
|
|
- .FirstOrDefault(i => string.Equals(i.Name, item.Album, StringComparison.OrdinalIgnoreCase));
|
|
|
+ var type = image.Key;
|
|
|
|
|
|
- if (parentAlbum != null)
|
|
|
+ var tag = GetImageCacheTag(item, type, image.Value);
|
|
|
+
|
|
|
+ if (tag.HasValue)
|
|
|
{
|
|
|
- dto.AlbumId = GetClientItemId(parentAlbum);
|
|
|
+ dto.ImageTags[type] = tag.Value;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- dto.Album = item.Album;
|
|
|
- dto.Artists = string.IsNullOrEmpty(item.Artist) ? new string[] { } : new[] { item.Artist };
|
|
|
- }
|
|
|
-
|
|
|
- private void SetGameProperties(BaseItemDto dto, Game item)
|
|
|
- {
|
|
|
- dto.Players = item.PlayersSupported;
|
|
|
- dto.GameSystem = item.GameSystem;
|
|
|
- }
|
|
|
+ dto.Id = GetDtoId(item);
|
|
|
+ dto.IndexNumber = item.IndexNumber;
|
|
|
+ dto.IsFolder = item.IsFolder;
|
|
|
+ dto.Language = item.Language;
|
|
|
+ dto.MediaType = item.MediaType;
|
|
|
+ dto.LocationType = item.LocationType;
|
|
|
+ dto.CriticRating = item.CriticRating;
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// Since it can be slow to make all of these calculations independently, this method will provide a way to do them all at once
|
|
|
- /// </summary>
|
|
|
- /// <param name="folder">The folder.</param>
|
|
|
- /// <param name="user">The user.</param>
|
|
|
- /// <param name="dto">The dto.</param>
|
|
|
- /// <param name="userDataRepository">The user data repository.</param>
|
|
|
- /// <returns>Task.</returns>
|
|
|
- private static void SetSpecialCounts(Folder folder, User user, BaseItemDto dto, IUserDataRepository userDataRepository)
|
|
|
- {
|
|
|
- var rcentlyAddedItemCount = 0;
|
|
|
- var recursiveItemCount = 0;
|
|
|
- var unplayed = 0;
|
|
|
- long runtime = 0;
|
|
|
+ if (fields.Contains(ItemFields.CriticRatingSummary))
|
|
|
+ {
|
|
|
+ dto.CriticRatingSummary = item.CriticRatingSummary;
|
|
|
+ }
|
|
|
|
|
|
- double totalPercentPlayed = 0;
|
|
|
+ var localTrailerCount = item.LocalTrailerIds.Count;
|
|
|
|
|
|
- // Loop through each recursive child
|
|
|
- foreach (var child in folder.GetRecursiveChildren(user, true).Where(i => !i.IsFolder).ToList())
|
|
|
+ if (localTrailerCount > 0)
|
|
|
{
|
|
|
- var userdata = userDataRepository.GetUserData(user.Id, child.GetUserDataKey());
|
|
|
+ dto.LocalTrailerCount = localTrailerCount;
|
|
|
+ }
|
|
|
|
|
|
- recursiveItemCount++;
|
|
|
+ dto.Name = item.Name;
|
|
|
+ dto.OfficialRating = item.OfficialRating;
|
|
|
|
|
|
- // Check is recently added
|
|
|
- if (child.IsRecentlyAdded())
|
|
|
- {
|
|
|
- rcentlyAddedItemCount++;
|
|
|
- }
|
|
|
+ var hasOverview = fields.Contains(ItemFields.Overview);
|
|
|
+ var hasHtmlOverview = fields.Contains(ItemFields.OverviewHtml);
|
|
|
|
|
|
- var isUnplayed = true;
|
|
|
+ if (hasOverview || hasHtmlOverview)
|
|
|
+ {
|
|
|
+ var strippedOverview = string.IsNullOrEmpty(item.Overview) ? item.Overview : item.Overview.StripHtml();
|
|
|
|
|
|
- // Incrememt totalPercentPlayed
|
|
|
- if (userdata != null)
|
|
|
+ if (hasOverview)
|
|
|
{
|
|
|
- if (userdata.Played)
|
|
|
- {
|
|
|
- totalPercentPlayed += 100;
|
|
|
-
|
|
|
- isUnplayed = false;
|
|
|
- }
|
|
|
- else if (userdata.PlaybackPositionTicks > 0 && child.RunTimeTicks.HasValue && child.RunTimeTicks.Value > 0)
|
|
|
- {
|
|
|
- double itemPercent = userdata.PlaybackPositionTicks;
|
|
|
- itemPercent /= child.RunTimeTicks.Value;
|
|
|
- totalPercentPlayed += itemPercent;
|
|
|
- }
|
|
|
+ dto.Overview = strippedOverview;
|
|
|
}
|
|
|
|
|
|
- if (isUnplayed)
|
|
|
+ // Only supply the html version if there was actually html content
|
|
|
+ if (hasHtmlOverview)
|
|
|
{
|
|
|
- unplayed++;
|
|
|
+ dto.OverviewHtml = item.Overview;
|
|
|
}
|
|
|
-
|
|
|
- runtime += child.RunTimeTicks ?? 0;
|
|
|
}
|
|
|
|
|
|
- dto.RecursiveItemCount = recursiveItemCount;
|
|
|
- dto.RecentlyAddedItemCount = rcentlyAddedItemCount;
|
|
|
- dto.RecursiveUnplayedItemCount = unplayed;
|
|
|
-
|
|
|
- if (recursiveItemCount > 0)
|
|
|
+ // If there are no backdrops, indicate what parent has them in case the Ui wants to allow inheritance
|
|
|
+ if (dto.BackdropImageTags.Count == 0)
|
|
|
{
|
|
|
- dto.PlayedPercentage = totalPercentPlayed / recursiveItemCount;
|
|
|
+ var parentWithBackdrop = GetParentBackdropItem(item, owner);
|
|
|
+
|
|
|
+ if (parentWithBackdrop != null)
|
|
|
+ {
|
|
|
+ dto.ParentBackdropItemId = GetDtoId(parentWithBackdrop);
|
|
|
+ dto.ParentBackdropImageTags = GetBackdropImageTags(parentWithBackdrop);
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
- if (runtime > 0)
|
|
|
+ if (item.Parent != null && fields.Contains(ItemFields.ParentId))
|
|
|
{
|
|
|
- dto.CumulativeRunTimeTicks = runtime;
|
|
|
+ dto.ParentId = GetDtoId(item.Parent);
|
|
|
}
|
|
|
- }
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// Attaches People DTO's to a DTOBaseItem
|
|
|
- /// </summary>
|
|
|
- /// <param name="dto">The dto.</param>
|
|
|
- /// <param name="item">The item.</param>
|
|
|
- /// <returns>Task.</returns>
|
|
|
- private async Task AttachPeople(BaseItemDto dto, BaseItem item)
|
|
|
- {
|
|
|
- // Ordering by person type to ensure actors and artists are at the front.
|
|
|
- // This is taking advantage of the fact that they both begin with A
|
|
|
- // This should be improved in the future
|
|
|
- var people = item.People.OrderBy(i => i.Type).ToList();
|
|
|
-
|
|
|
- // Attach People by transforming them into BaseItemPerson (DTO)
|
|
|
- dto.People = new BaseItemPerson[people.Count];
|
|
|
-
|
|
|
- var entities = await Task.WhenAll(people.Select(p => p.Name)
|
|
|
- .Distinct(StringComparer.OrdinalIgnoreCase).Select(c =>
|
|
|
- Task.Run(async () =>
|
|
|
- {
|
|
|
- try
|
|
|
- {
|
|
|
- return await _libraryManager.GetPerson(c).ConfigureAwait(false);
|
|
|
- }
|
|
|
- catch (IOException ex)
|
|
|
- {
|
|
|
- _logger.ErrorException("Error getting person {0}", ex, c);
|
|
|
- return null;
|
|
|
- }
|
|
|
- })
|
|
|
-
|
|
|
- )).ConfigureAwait(false);
|
|
|
-
|
|
|
- var dictionary = entities.Where(i => i != null)
|
|
|
- .DistinctBy(i => i.Name)
|
|
|
- .ToDictionary(i => i.Name, StringComparer.OrdinalIgnoreCase);
|
|
|
+ dto.ParentIndexNumber = item.ParentIndexNumber;
|
|
|
|
|
|
- for (var i = 0; i < people.Count; i++)
|
|
|
+ // If there is no logo, indicate what parent has one in case the Ui wants to allow inheritance
|
|
|
+ if (!dto.HasLogo)
|
|
|
{
|
|
|
- var person = people[i];
|
|
|
+ var parentWithLogo = GetParentImageItem(item, ImageType.Logo, owner);
|
|
|
|
|
|
- var baseItemPerson = new BaseItemPerson
|
|
|
+ if (parentWithLogo != null)
|
|
|
{
|
|
|
- Name = person.Name,
|
|
|
- Role = person.Role,
|
|
|
- Type = person.Type
|
|
|
- };
|
|
|
+ dto.ParentLogoItemId = GetDtoId(parentWithLogo);
|
|
|
|
|
|
- Person entity;
|
|
|
+ dto.ParentLogoImageTag = GetImageCacheTag(parentWithLogo, ImageType.Logo, parentWithLogo.GetImage(ImageType.Logo));
|
|
|
+ }
|
|
|
+ }
|
|
|
|
|
|
- if (dictionary.TryGetValue(person.Name, out entity))
|
|
|
+ // If there is no art, indicate what parent has one in case the Ui wants to allow inheritance
|
|
|
+ if (!dto.HasArtImage)
|
|
|
+ {
|
|
|
+ var parentWithImage = GetParentImageItem(item, ImageType.Art, owner);
|
|
|
+
|
|
|
+ if (parentWithImage != null)
|
|
|
{
|
|
|
- var primaryImagePath = entity.PrimaryImagePath;
|
|
|
+ dto.ParentArtItemId = GetDtoId(parentWithImage);
|
|
|
|
|
|
- if (!string.IsNullOrEmpty(primaryImagePath))
|
|
|
- {
|
|
|
- baseItemPerson.PrimaryImageTag = GetImageCacheTag(entity, ImageType.Primary, primaryImagePath);
|
|
|
- }
|
|
|
+ dto.ParentArtImageTag = GetImageCacheTag(parentWithImage, ImageType.Art, parentWithImage.GetImage(ImageType.Art));
|
|
|
}
|
|
|
+ }
|
|
|
|
|
|
- dto.People[i] = baseItemPerson;
|
|
|
+ if (fields.Contains(ItemFields.Path))
|
|
|
+ {
|
|
|
+ dto.Path = item.Path;
|
|
|
}
|
|
|
- }
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// Attaches the studios.
|
|
|
- /// </summary>
|
|
|
- /// <param name="dto">The dto.</param>
|
|
|
- /// <param name="item">The item.</param>
|
|
|
- /// <returns>Task.</returns>
|
|
|
- private async Task AttachStudios(BaseItemDto dto, BaseItem item)
|
|
|
- {
|
|
|
- var studios = item.Studios.ToList();
|
|
|
+ dto.PremiereDate = item.PremiereDate;
|
|
|
+ dto.ProductionYear = item.ProductionYear;
|
|
|
|
|
|
- dto.Studios = new StudioDto[studios.Count];
|
|
|
+ if (fields.Contains(ItemFields.ProviderIds))
|
|
|
+ {
|
|
|
+ dto.ProviderIds = item.ProviderIds;
|
|
|
+ }
|
|
|
|
|
|
- var entities = await Task.WhenAll(studios.Distinct(StringComparer.OrdinalIgnoreCase).Select(c =>
|
|
|
+ dto.RunTimeTicks = item.RunTimeTicks;
|
|
|
|
|
|
- Task.Run(async () =>
|
|
|
- {
|
|
|
- try
|
|
|
- {
|
|
|
- return await _libraryManager.GetStudio(c).ConfigureAwait(false);
|
|
|
- }
|
|
|
- catch (IOException ex)
|
|
|
- {
|
|
|
- _logger.ErrorException("Error getting studio {0}", ex, c);
|
|
|
- return null;
|
|
|
- }
|
|
|
- })
|
|
|
+ if (fields.Contains(ItemFields.SortName))
|
|
|
+ {
|
|
|
+ dto.SortName = item.SortName;
|
|
|
+ }
|
|
|
|
|
|
- )).ConfigureAwait(false);
|
|
|
+ if (fields.Contains(ItemFields.CustomRating))
|
|
|
+ {
|
|
|
+ dto.CustomRating = item.CustomRating;
|
|
|
+ }
|
|
|
|
|
|
- var dictionary = entities
|
|
|
- .Where(i => i != null)
|
|
|
- .ToDictionary(i => i.Name, StringComparer.OrdinalIgnoreCase);
|
|
|
+ if (fields.Contains(ItemFields.Taglines))
|
|
|
+ {
|
|
|
+ dto.Taglines = item.Taglines;
|
|
|
+ }
|
|
|
|
|
|
- for (var i = 0; i < studios.Count; i++)
|
|
|
+ if (fields.Contains(ItemFields.RemoteTrailers))
|
|
|
{
|
|
|
- var studio = studios[i];
|
|
|
+ dto.RemoteTrailers = item.RemoteTrailers;
|
|
|
+ }
|
|
|
|
|
|
- var studioDto = new StudioDto
|
|
|
- {
|
|
|
- Name = studio
|
|
|
- };
|
|
|
+ dto.Type = item.GetType().Name;
|
|
|
+ dto.CommunityRating = item.CommunityRating;
|
|
|
|
|
|
- Studio entity;
|
|
|
+ if (item.IsFolder)
|
|
|
+ {
|
|
|
+ var folder = (Folder)item;
|
|
|
|
|
|
- if (dictionary.TryGetValue(studio, out entity))
|
|
|
+ if (fields.Contains(ItemFields.IndexOptions))
|
|
|
{
|
|
|
- var primaryImagePath = entity.PrimaryImagePath;
|
|
|
-
|
|
|
- if (!string.IsNullOrEmpty(primaryImagePath))
|
|
|
- {
|
|
|
- studioDto.PrimaryImageTag = GetImageCacheTag(entity, ImageType.Primary, primaryImagePath);
|
|
|
- }
|
|
|
+ dto.IndexOptions = folder.IndexByOptionStrings.ToArray();
|
|
|
}
|
|
|
-
|
|
|
- dto.Studios[i] = studioDto;
|
|
|
}
|
|
|
- }
|
|
|
-
|
|
|
- /// <summary>
|
|
|
- /// If an item does not any backdrops, this can be used to find the first parent that does have one
|
|
|
- /// </summary>
|
|
|
- /// <param name="item">The item.</param>
|
|
|
- /// <param name="owner">The owner.</param>
|
|
|
- /// <returns>BaseItem.</returns>
|
|
|
- private BaseItem GetParentBackdropItem(BaseItem item, BaseItem owner)
|
|
|
- {
|
|
|
- var parent = item.Parent ?? owner;
|
|
|
|
|
|
- while (parent != null)
|
|
|
+ // Add audio info
|
|
|
+ var audio = item as Audio;
|
|
|
+ if (audio != null)
|
|
|
{
|
|
|
- if (parent.BackdropImagePaths != null && parent.BackdropImagePaths.Count > 0)
|
|
|
- {
|
|
|
- return parent;
|
|
|
- }
|
|
|
+ dto.Album = audio.Album;
|
|
|
+ dto.AlbumArtist = audio.AlbumArtist;
|
|
|
+ dto.Artists = new[] { audio.Artist };
|
|
|
|
|
|
- parent = parent.Parent;
|
|
|
- }
|
|
|
+ var albumParent = audio.FindParent<MusicAlbum>();
|
|
|
|
|
|
- return null;
|
|
|
- }
|
|
|
+ if (albumParent != null)
|
|
|
+ {
|
|
|
+ dto.AlbumId = GetDtoId(albumParent);
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// If an item does not have a logo, this can be used to find the first parent that does have one
|
|
|
- /// </summary>
|
|
|
- /// <param name="item">The item.</param>
|
|
|
- /// <param name="type">The type.</param>
|
|
|
- /// <param name="owner">The owner.</param>
|
|
|
- /// <returns>BaseItem.</returns>
|
|
|
- private BaseItem GetParentImageItem(BaseItem item, ImageType type, BaseItem owner)
|
|
|
- {
|
|
|
- var parent = item.Parent ?? owner;
|
|
|
+ var imagePath = albumParent.PrimaryImagePath;
|
|
|
|
|
|
- while (parent != null)
|
|
|
- {
|
|
|
- if (parent.HasImage(type))
|
|
|
- {
|
|
|
- return parent;
|
|
|
+ if (!string.IsNullOrEmpty(imagePath))
|
|
|
+ {
|
|
|
+ dto.AlbumPrimaryImageTag = GetImageCacheTag(albumParent, ImageType.Primary, imagePath);
|
|
|
+ }
|
|
|
}
|
|
|
-
|
|
|
- parent = parent.Parent;
|
|
|
}
|
|
|
|
|
|
- return null;
|
|
|
- }
|
|
|
+ var album = item as MusicAlbum;
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// Converts a UserItemData to a DTOUserItemData
|
|
|
- /// </summary>
|
|
|
- /// <param name="data">The data.</param>
|
|
|
- /// <returns>DtoUserItemData.</returns>
|
|
|
- /// <exception cref="System.ArgumentNullException"></exception>
|
|
|
- public static UserItemDataDto GetUserItemDataDto(UserItemData data)
|
|
|
- {
|
|
|
- if (data == null)
|
|
|
+ if (album != null)
|
|
|
{
|
|
|
- throw new ArgumentNullException("data");
|
|
|
- }
|
|
|
+ var songs = album.RecursiveChildren.OfType<Audio>().ToList();
|
|
|
|
|
|
- return new UserItemDataDto
|
|
|
- {
|
|
|
- IsFavorite = data.IsFavorite,
|
|
|
- Likes = data.Likes,
|
|
|
- PlaybackPositionTicks = data.PlaybackPositionTicks,
|
|
|
- PlayCount = data.PlayCount,
|
|
|
- Rating = data.Rating,
|
|
|
- Played = data.Played,
|
|
|
- LastPlayedDate = data.LastPlayedDate
|
|
|
- };
|
|
|
- }
|
|
|
+ dto.AlbumArtist = songs.Select(i => i.AlbumArtist).FirstOrDefault(i => !string.IsNullOrEmpty(i));
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// Gets the chapter info dto.
|
|
|
- /// </summary>
|
|
|
- /// <param name="chapterInfo">The chapter info.</param>
|
|
|
- /// <param name="item">The item.</param>
|
|
|
- /// <returns>ChapterInfoDto.</returns>
|
|
|
- private ChapterInfoDto GetChapterInfoDto(ChapterInfo chapterInfo, BaseItem item)
|
|
|
- {
|
|
|
- var dto = new ChapterInfoDto
|
|
|
- {
|
|
|
- Name = chapterInfo.Name,
|
|
|
- StartPositionTicks = chapterInfo.StartPositionTicks
|
|
|
- };
|
|
|
+ dto.Artists =
|
|
|
+ songs.Select(i => i.Artist ?? string.Empty)
|
|
|
+ .Where(i => !string.IsNullOrEmpty(i))
|
|
|
+ .Distinct(StringComparer.OrdinalIgnoreCase)
|
|
|
+ .ToArray();
|
|
|
+ }
|
|
|
|
|
|
- if (!string.IsNullOrEmpty(chapterInfo.ImagePath))
|
|
|
+ // Add video info
|
|
|
+ var video = item as Video;
|
|
|
+ if (video != null)
|
|
|
{
|
|
|
- dto.ImageTag = GetImageCacheTag(item, ImageType.Chapter, chapterInfo.ImagePath);
|
|
|
- }
|
|
|
+ dto.VideoType = video.VideoType;
|
|
|
+ dto.Video3DFormat = video.Video3DFormat;
|
|
|
+ dto.IsoType = video.IsoType;
|
|
|
+ dto.MainFeaturePlaylistName = video.MainFeaturePlaylistName;
|
|
|
|
|
|
- return dto;
|
|
|
- }
|
|
|
+ dto.PartCount = video.AdditionalPartIds.Count + 1;
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// Converts a BaseItem to a BaseItemInfo
|
|
|
- /// </summary>
|
|
|
- /// <param name="item">The item.</param>
|
|
|
- /// <returns>BaseItemInfo.</returns>
|
|
|
- /// <exception cref="System.ArgumentNullException">item</exception>
|
|
|
- public static BaseItemInfo GetBaseItemInfo(BaseItem item)
|
|
|
- {
|
|
|
- if (item == null)
|
|
|
- {
|
|
|
- throw new ArgumentNullException("item");
|
|
|
+ if (fields.Contains(ItemFields.Chapters))
|
|
|
+ {
|
|
|
+ dto.Chapters = _itemRepo.GetChapters(video.Id).Select(c => GetChapterInfoDto(c, item)).ToList();
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
- var info = new BaseItemInfo
|
|
|
+ if (fields.Contains(ItemFields.MediaStreams))
|
|
|
{
|
|
|
- Id = GetClientItemId(item),
|
|
|
- Name = item.Name,
|
|
|
- MediaType = item.MediaType,
|
|
|
- Type = item.GetType().Name,
|
|
|
- IsFolder = item.IsFolder,
|
|
|
- RunTimeTicks = item.RunTimeTicks
|
|
|
- };
|
|
|
+ // Add VideoInfo
|
|
|
+ var iHasMediaStreams = item as IHasMediaStreams;
|
|
|
|
|
|
- var imagePath = item.PrimaryImagePath;
|
|
|
+ if (iHasMediaStreams != null)
|
|
|
+ {
|
|
|
+ dto.MediaStreams = iHasMediaStreams.MediaStreams;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ // Add MovieInfo
|
|
|
+ var movie = item as Movie;
|
|
|
|
|
|
- if (!string.IsNullOrEmpty(imagePath))
|
|
|
+ if (movie != null)
|
|
|
{
|
|
|
- try
|
|
|
- {
|
|
|
- info.PrimaryImageTag = Kernel.Instance.ImageManager.GetImageCacheTag(item, ImageType.Primary, imagePath);
|
|
|
- }
|
|
|
- catch (IOException)
|
|
|
+ var specialFeatureCount = movie.SpecialFeatureIds.Count;
|
|
|
+
|
|
|
+ if (specialFeatureCount > 0)
|
|
|
{
|
|
|
+ dto.SpecialFeatureCount = specialFeatureCount;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
- return info;
|
|
|
- }
|
|
|
+ // Add EpisodeInfo
|
|
|
+ var episode = item as Episode;
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// Gets client-side Id of a server-side BaseItem
|
|
|
- /// </summary>
|
|
|
- /// <param name="item">The item.</param>
|
|
|
- /// <returns>System.String.</returns>
|
|
|
- /// <exception cref="System.ArgumentNullException">item</exception>
|
|
|
- public static string GetClientItemId(BaseItem item)
|
|
|
- {
|
|
|
- if (item == null)
|
|
|
+ if (episode != null)
|
|
|
{
|
|
|
- throw new ArgumentNullException("item");
|
|
|
+ dto.IndexNumberEnd = episode.IndexNumberEnd;
|
|
|
}
|
|
|
|
|
|
- var indexFolder = item as IndexFolder;
|
|
|
+ // Add SeriesInfo
|
|
|
+ var series = item as Series;
|
|
|
|
|
|
- if (indexFolder != null)
|
|
|
+ if (series != null)
|
|
|
{
|
|
|
- return GetClientItemId(indexFolder.Parent) + IndexFolderDelimeter + (indexFolder.IndexName ?? string.Empty) + IndexFolderDelimeter + indexFolder.Id;
|
|
|
- }
|
|
|
+ dto.AirDays = series.AirDays;
|
|
|
+ dto.AirTime = series.AirTime;
|
|
|
+ dto.Status = series.Status;
|
|
|
|
|
|
- return item.Id.ToString("N");
|
|
|
- }
|
|
|
+ dto.SpecialFeatureCount = series.SpecialFeatureIds.Count;
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// Gets a BaseItem based upon it's client-side item id
|
|
|
- /// </summary>
|
|
|
- /// <param name="id">The id.</param>
|
|
|
- /// <param name="userManager">The user manager.</param>
|
|
|
- /// <param name="libraryManager">The library manager.</param>
|
|
|
- /// <param name="userId">The user id.</param>
|
|
|
- /// <returns>BaseItem.</returns>
|
|
|
- public static BaseItem GetItemByClientId(string id, IUserManager userManager, ILibraryManager libraryManager, Guid? userId = null)
|
|
|
- {
|
|
|
- if (string.IsNullOrEmpty(id))
|
|
|
+ dto.SeasonCount = series.SeasonCount;
|
|
|
+ }
|
|
|
+
|
|
|
+ if (episode != null)
|
|
|
{
|
|
|
- throw new ArgumentNullException("id");
|
|
|
+ series = item.FindParent<Series>();
|
|
|
+
|
|
|
+ dto.SeriesId = GetDtoId(series);
|
|
|
+ dto.SeriesName = series.Name;
|
|
|
}
|
|
|
|
|
|
- // If the item is an indexed folder we have to do a special routine to get it
|
|
|
- var isIndexFolder = id.IndexOf(IndexFolderDelimeter, StringComparison.OrdinalIgnoreCase) != -1;
|
|
|
+ // Add SeasonInfo
|
|
|
+ var season = item as Season;
|
|
|
|
|
|
- if (isIndexFolder)
|
|
|
+ if (season != null)
|
|
|
{
|
|
|
- if (userId.HasValue)
|
|
|
- {
|
|
|
- return GetIndexFolder(id, userId.Value, userManager, libraryManager);
|
|
|
- }
|
|
|
+ series = item.FindParent<Series>();
|
|
|
+
|
|
|
+ dto.SeriesId = GetDtoId(series);
|
|
|
+ dto.SeriesName = series.Name;
|
|
|
}
|
|
|
|
|
|
- BaseItem item = null;
|
|
|
+ var game = item as Game;
|
|
|
|
|
|
- if (userId.HasValue || !isIndexFolder)
|
|
|
+ if (game != null)
|
|
|
{
|
|
|
- item = libraryManager.GetItemById(new Guid(id));
|
|
|
+ SetGameProperties(dto, game);
|
|
|
}
|
|
|
|
|
|
- // If we still don't find it, look within individual user views
|
|
|
- if (item == null && !userId.HasValue && isIndexFolder)
|
|
|
- {
|
|
|
- foreach (var user in userManager.Users)
|
|
|
- {
|
|
|
- item = GetItemByClientId(id, userManager, libraryManager, user.Id);
|
|
|
+ var musicVideo = item as MusicVideo;
|
|
|
|
|
|
- if (item != null)
|
|
|
- {
|
|
|
- break;
|
|
|
- }
|
|
|
- }
|
|
|
+ if (musicVideo != null)
|
|
|
+ {
|
|
|
+ SetMusicVideoProperties(dto, musicVideo);
|
|
|
}
|
|
|
|
|
|
- return item;
|
|
|
+ var book = item as Book;
|
|
|
+
|
|
|
+ if (book != null)
|
|
|
+ {
|
|
|
+ SetBookProperties(dto, book);
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
- /// Finds an index folder based on an Id and userId
|
|
|
+ /// Since it can be slow to make all of these calculations independently, this method will provide a way to do them all at once
|
|
|
/// </summary>
|
|
|
- /// <param name="id">The id.</param>
|
|
|
- /// <param name="userId">The user id.</param>
|
|
|
- /// <param name="userManager">The user manager.</param>
|
|
|
- /// <param name="libraryManager">The library manager.</param>
|
|
|
- /// <returns>BaseItem.</returns>
|
|
|
- private static BaseItem GetIndexFolder(string id, Guid userId, IUserManager userManager, ILibraryManager libraryManager)
|
|
|
+ /// <param name="folder">The folder.</param>
|
|
|
+ /// <param name="user">The user.</param>
|
|
|
+ /// <param name="dto">The dto.</param>
|
|
|
+ /// <returns>Task.</returns>
|
|
|
+ private void SetSpecialCounts(Folder folder, User user, BaseItemDto dto)
|
|
|
{
|
|
|
- var user = userManager.GetUserById(userId);
|
|
|
+ var rcentlyAddedItemCount = 0;
|
|
|
+ var recursiveItemCount = 0;
|
|
|
+ var unplayed = 0;
|
|
|
+ long runtime = 0;
|
|
|
|
|
|
- var stringSeparators = new[] { IndexFolderDelimeter };
|
|
|
+ double totalPercentPlayed = 0;
|
|
|
|
|
|
- // Split using the delimeter
|
|
|
- var values = id.Split(stringSeparators, StringSplitOptions.None).ToList();
|
|
|
+ // Loop through each recursive child
|
|
|
+ foreach (var child in folder.GetRecursiveChildren(user, true).Where(i => !i.IsFolder).ToList())
|
|
|
+ {
|
|
|
+ var userdata = _userDataRepository.GetUserData(user.Id, child.GetUserDataKey());
|
|
|
|
|
|
- // Get the top folder normally using the first id
|
|
|
- var folder = GetItemByClientId(values[0], userManager, libraryManager, userId) as Folder;
|
|
|
+ recursiveItemCount++;
|
|
|
|
|
|
- values.RemoveAt(0);
|
|
|
+ // Check is recently added
|
|
|
+ if (child.IsRecentlyAdded())
|
|
|
+ {
|
|
|
+ rcentlyAddedItemCount++;
|
|
|
+ }
|
|
|
|
|
|
- // Get indexed folders using the remaining values in the id string
|
|
|
- return GetIndexFolder(values, folder, user);
|
|
|
- }
|
|
|
+ var isUnplayed = true;
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// Gets indexed folders based on a list of index names and folder id's
|
|
|
- /// </summary>
|
|
|
- /// <param name="values">The values.</param>
|
|
|
- /// <param name="parentFolder">The parent folder.</param>
|
|
|
- /// <param name="user">The user.</param>
|
|
|
- /// <returns>BaseItem.</returns>
|
|
|
- private static BaseItem GetIndexFolder(List<string> values, Folder parentFolder, User user)
|
|
|
- {
|
|
|
- // The index name is first
|
|
|
- var indexBy = values[0];
|
|
|
+ // Incrememt totalPercentPlayed
|
|
|
+ if (userdata != null)
|
|
|
+ {
|
|
|
+ if (userdata.Played)
|
|
|
+ {
|
|
|
+ totalPercentPlayed += 100;
|
|
|
|
|
|
- // The index folder id is next
|
|
|
- var indexFolderId = new Guid(values[1]);
|
|
|
+ isUnplayed = false;
|
|
|
+ }
|
|
|
+ else if (userdata.PlaybackPositionTicks > 0 && child.RunTimeTicks.HasValue && child.RunTimeTicks.Value > 0)
|
|
|
+ {
|
|
|
+ double itemPercent = userdata.PlaybackPositionTicks;
|
|
|
+ itemPercent /= child.RunTimeTicks.Value;
|
|
|
+ totalPercentPlayed += itemPercent;
|
|
|
+ }
|
|
|
+ }
|
|
|
|
|
|
- // Remove them from the lst
|
|
|
- values.RemoveRange(0, 2);
|
|
|
+ if (isUnplayed)
|
|
|
+ {
|
|
|
+ unplayed++;
|
|
|
+ }
|
|
|
|
|
|
- // Get the IndexFolder
|
|
|
- var indexFolder = parentFolder.GetChildren(user, false, indexBy).FirstOrDefault(i => i.Id == indexFolderId) as Folder;
|
|
|
+ runtime += child.RunTimeTicks ?? 0;
|
|
|
+ }
|
|
|
|
|
|
- // Nested index folder
|
|
|
- if (values.Count > 0)
|
|
|
+ dto.RecursiveItemCount = recursiveItemCount;
|
|
|
+ dto.RecentlyAddedItemCount = rcentlyAddedItemCount;
|
|
|
+ dto.RecursiveUnplayedItemCount = unplayed;
|
|
|
+
|
|
|
+ if (recursiveItemCount > 0)
|
|
|
{
|
|
|
- return GetIndexFolder(values, indexFolder, user);
|
|
|
+ dto.PlayedPercentage = totalPercentPlayed / recursiveItemCount;
|
|
|
}
|
|
|
|
|
|
- return indexFolder;
|
|
|
+ if (runtime > 0)
|
|
|
+ {
|
|
|
+ dto.CumulativeRunTimeTicks = runtime;
|
|
|
+ }
|
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
|
- /// Gets the backdrop image tags.
|
|
|
+ /// Attaches the primary image aspect ratio.
|
|
|
/// </summary>
|
|
|
+ /// <param name="dto">The dto.</param>
|
|
|
/// <param name="item">The item.</param>
|
|
|
- /// <returns>List{System.String}.</returns>
|
|
|
- private List<Guid> GetBackdropImageTags(BaseItem item)
|
|
|
+ /// <param name="logger">The _logger.</param>
|
|
|
+ /// <returns>Task.</returns>
|
|
|
+ private async Task AttachPrimaryImageAspectRatio(IItemDto dto, BaseItem item)
|
|
|
{
|
|
|
- return item.BackdropImagePaths
|
|
|
- .Select(p => GetImageCacheTag(item, ImageType.Backdrop, p))
|
|
|
- .Where(i => i.HasValue)
|
|
|
- .Select(i => i.Value)
|
|
|
- .ToList();
|
|
|
- }
|
|
|
+ var path = item.PrimaryImagePath;
|
|
|
|
|
|
- /// <summary>
|
|
|
- /// Gets the screenshot image tags.
|
|
|
- /// </summary>
|
|
|
- /// <param name="item">The item.</param>
|
|
|
- /// <returns>List{Guid}.</returns>
|
|
|
- private List<Guid> GetScreenshotImageTags(BaseItem item)
|
|
|
- {
|
|
|
- return item.ScreenshotImagePaths
|
|
|
- .Select(p => GetImageCacheTag(item, ImageType.Screenshot, p))
|
|
|
- .Where(i => i.HasValue)
|
|
|
- .Select(i => i.Value)
|
|
|
- .ToList();
|
|
|
- }
|
|
|
+ if (string.IsNullOrEmpty(path))
|
|
|
+ {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ var metaFileEntry = item.ResolveArgs.GetMetaFileByPath(path);
|
|
|
+
|
|
|
+ // See if we can avoid a file system lookup by looking for the file in ResolveArgs
|
|
|
+ var dateModified = metaFileEntry == null ? File.GetLastWriteTimeUtc(path) : metaFileEntry.LastWriteTimeUtc;
|
|
|
+
|
|
|
+ ImageSize size;
|
|
|
|
|
|
- private Guid? GetImageCacheTag(BaseItem item, ImageType type, string path)
|
|
|
- {
|
|
|
try
|
|
|
{
|
|
|
- return Kernel.Instance.ImageManager.GetImageCacheTag(item, type, path);
|
|
|
+ size = await Kernel.Instance.ImageManager.GetImageSize(path, dateModified).ConfigureAwait(false);
|
|
|
}
|
|
|
- catch (IOException ex)
|
|
|
+ catch (FileNotFoundException)
|
|
|
{
|
|
|
- _logger.ErrorException("Error getting {0} image info for {1}", ex, type, path);
|
|
|
- return null;
|
|
|
+ _logger.Error("Image file does not exist: {0}", path);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+ catch (Exception ex)
|
|
|
+ {
|
|
|
+ _logger.ErrorException("Failed to determine primary image aspect ratio for {0}", ex, path);
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ dto.OriginalPrimaryImageAspectRatio = size.Width / size.Height;
|
|
|
+
|
|
|
+ var supportedEnhancers = Kernel.Instance.ImageManager.ImageEnhancers.Where(i =>
|
|
|
+ {
|
|
|
+ try
|
|
|
+ {
|
|
|
+ return i.Supports(item, ImageType.Primary);
|
|
|
+ }
|
|
|
+ catch (Exception ex)
|
|
|
+ {
|
|
|
+ _logger.ErrorException("Error in image enhancer: {0}", ex, i.GetType().Name);
|
|
|
+
|
|
|
+ return false;
|
|
|
+ }
|
|
|
+
|
|
|
+ }).ToList();
|
|
|
+
|
|
|
+
|
|
|
+ foreach (var enhancer in supportedEnhancers)
|
|
|
+ {
|
|
|
+ try
|
|
|
+ {
|
|
|
+ size = enhancer.GetEnhancedImageSize(item, ImageType.Primary, 0, size);
|
|
|
+ }
|
|
|
+ catch (Exception ex)
|
|
|
+ {
|
|
|
+ _logger.ErrorException("Error in image enhancer: {0}", ex, enhancer.GetType().Name);
|
|
|
+ }
|
|
|
}
|
|
|
+
|
|
|
+ dto.PrimaryImageAspectRatio = size.Width / size.Height;
|
|
|
}
|
|
|
+
|
|
|
}
|
|
|
}
|
Luke Pulverenti