jellyfin-server/MediaBrowser.Server.Implementations/Dto/DtoService.cs

1338 lines
43 KiB
C#
Raw Normal View History

using MediaBrowser.Common.Extensions;
2014-02-07 20:30:41 +00:00
using MediaBrowser.Common.IO;
2014-01-30 05:20:18 +00:00
using MediaBrowser.Controller.Configuration;
2013-09-18 18:49:06 +00:00
using MediaBrowser.Controller.Drawing;
2013-09-04 17:02:19 +00:00
using MediaBrowser.Controller.Dto;
using MediaBrowser.Controller.Entities;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Controller.Entities.Audio;
using MediaBrowser.Controller.Entities.Movies;
using MediaBrowser.Controller.Entities.TV;
using MediaBrowser.Controller.Library;
using MediaBrowser.Controller.Persistence;
2013-09-04 17:02:19 +00:00
using MediaBrowser.Controller.Session;
2014-01-30 05:20:18 +00:00
using MediaBrowser.Model.Configuration;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Model.Drawing;
using MediaBrowser.Model.Dto;
2013-02-21 01:33:05 +00:00
using MediaBrowser.Model.Entities;
2013-02-21 06:38:23 +00:00
using MediaBrowser.Model.Logging;
using MediaBrowser.Model.Querying;
2013-09-04 17:02:19 +00:00
using MediaBrowser.Model.Session;
using MoreLinq;
2013-02-21 01:33:05 +00:00
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
2013-09-04 17:02:19 +00:00
namespace MediaBrowser.Server.Implementations.Dto
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
public class DtoService : IDtoService
2013-02-21 01:33:05 +00:00
{
private readonly ILogger _logger;
private readonly ILibraryManager _libraryManager;
2013-09-04 17:02:19 +00:00
private readonly IUserManager _userManager;
2013-10-02 16:08:58 +00:00
private readonly IUserDataManager _userDataRepository;
2013-06-18 19:16:27 +00:00
private readonly IItemRepository _itemRepo;
2013-09-18 18:49:06 +00:00
private readonly IImageProcessor _imageProcessor;
2014-01-30 05:20:18 +00:00
private readonly IServerConfigurationManager _config;
2014-02-07 20:30:41 +00:00
private readonly IFileSystem _fileSystem;
2013-10-02 16:08:58 +00:00
2014-02-07 20:30:41 +00:00
public DtoService(ILogger logger, ILibraryManager libraryManager, IUserManager userManager, IUserDataManager userDataRepository, IItemRepository itemRepo, IImageProcessor imageProcessor, IServerConfigurationManager config, IFileSystem fileSystem)
{
_logger = logger;
_libraryManager = libraryManager;
2013-09-04 17:02:19 +00:00
_userManager = userManager;
_userDataRepository = userDataRepository;
2013-06-18 19:16:27 +00:00
_itemRepo = itemRepo;
2013-09-18 18:49:06 +00:00
_imageProcessor = imageProcessor;
2014-01-30 05:20:18 +00:00
_config = config;
2014-02-07 20:30:41 +00:00
_fileSystem = fileSystem;
}
2013-02-21 01:33:05 +00:00
/// <summary>
2013-05-15 16:56:38 +00:00
/// Converts a BaseItem to a DTOBaseItem
2013-02-21 01:33:05 +00:00
/// </summary>
/// <param name="item">The item.</param>
/// <param name="fields">The fields.</param>
2013-05-15 16:56:38 +00:00
/// <param name="user">The user.</param>
/// <param name="owner">The owner.</param>
2013-02-21 01:33:05 +00:00
/// <returns>Task{DtoBaseItem}.</returns>
/// <exception cref="System.ArgumentNullException">item</exception>
2013-09-17 02:44:06 +00:00
public BaseItemDto GetBaseItemDto(BaseItem item, List<ItemFields> fields, User user = null, BaseItem owner = null)
2013-02-21 01:33:05 +00:00
{
if (item == null)
{
throw new ArgumentNullException("item");
}
2013-05-15 16:56:38 +00:00
2013-02-21 01:33:05 +00:00
if (fields == null)
{
throw new ArgumentNullException("fields");
}
var dto = new BaseItemDto();
2013-02-21 01:33:05 +00:00
2013-04-03 02:59:27 +00:00
if (fields.Contains(ItemFields.People))
{
AttachPeople(dto, item);
2013-04-03 02:59:27 +00:00
}
if (fields.Contains(ItemFields.PrimaryImageAspectRatio))
{
try
{
2013-09-17 02:44:06 +00:00
AttachPrimaryImageAspectRatio(dto, item);
2013-04-03 02:59:27 +00:00
}
catch (Exception ex)
{
// Have to use a catch-all unfortunately because some .net image methods throw plain Exceptions
_logger.ErrorException("Error generating PrimaryImageAspectRatio for {0}", ex, item.Name);
}
}
if (fields.Contains(ItemFields.DisplayPreferencesId))
{
dto.DisplayPreferencesId = item.DisplayPreferencesId.ToString("N");
}
2013-06-17 20:35:43 +00:00
if (user != null)
{
AttachUserSpecificInfo(dto, item, user, fields);
}
if (fields.Contains(ItemFields.Studios))
{
AttachStudios(dto, item);
}
AttachBasicFields(dto, item, owner, fields);
2013-02-21 01:33:05 +00:00
2013-07-16 16:03:28 +00:00
if (fields.Contains(ItemFields.SoundtrackIds))
{
2013-11-12 15:36:08 +00:00
var hasSoundtracks = item as IHasSoundtracks;
if (hasSoundtracks != null)
{
dto.SoundtrackIds = hasSoundtracks.SoundtrackIds
.Select(i => i.ToString("N"))
.ToArray();
}
2013-07-16 16:03:28 +00:00
}
var itemByName = item as IItemByName;
if (itemByName != null)
{
AttachItemByNameCounts(dto, itemByName, user);
}
2013-02-21 01:33:05 +00:00
return dto;
}
/// <summary>
/// Attaches the item by name counts.
/// </summary>
/// <param name="dto">The dto.</param>
/// <param name="item">The item.</param>
/// <param name="user">The user.</param>
private void AttachItemByNameCounts(BaseItemDto dto, IItemByName item, User user)
{
if (user == null)
{
2013-09-11 17:54:59 +00:00
return;
}
2013-12-02 21:46:22 +00:00
2014-01-14 20:03:35 +00:00
var counts = item.GetItemByNameCounts(user.Id) ?? new ItemByNameCounts();
dto.ChildCount = counts.TotalCount;
dto.AdultVideoCount = counts.AdultVideoCount;
dto.AlbumCount = counts.AlbumCount;
dto.EpisodeCount = counts.EpisodeCount;
dto.GameCount = counts.GameCount;
dto.MovieCount = counts.MovieCount;
dto.MusicVideoCount = counts.MusicVideoCount;
dto.SeriesCount = counts.SeriesCount;
dto.SongCount = counts.SongCount;
dto.TrailerCount = counts.TrailerCount;
}
2013-02-21 01:33:05 +00:00
/// <summary>
/// Attaches the user specific info.
/// </summary>
/// <param name="dto">The dto.</param>
/// <param name="item">The item.</param>
/// <param name="user">The user.</param>
/// <param name="fields">The fields.</param>
2013-06-17 20:35:43 +00:00
private void AttachUserSpecificInfo(BaseItemDto dto, BaseItem item, User user, List<ItemFields> fields)
2013-02-21 01:33:05 +00:00
{
if (item.IsFolder)
{
var folder = (Folder)item;
2013-07-25 19:17:44 +00:00
dto.ChildCount = GetChildCount(folder, user);
2013-02-21 01:33:05 +00:00
if (!(folder is UserRootFolder))
{
SetSpecialCounts(folder, user, dto, fields);
2013-02-21 01:33:05 +00:00
}
}
2013-05-08 01:17:41 +00:00
2013-07-16 17:18:32 +00:00
var userData = _userDataRepository.GetUserData(user.Id, item.GetUserDataKey());
2013-05-08 01:17:41 +00:00
2013-07-16 17:18:32 +00:00
dto.UserData = GetUserItemDataDto(userData);
2013-05-08 01:17:41 +00:00
2013-07-16 17:18:32 +00:00
if (item.IsFolder)
{
dto.UserData.Played = dto.PlayedPercentage.HasValue && dto.PlayedPercentage.Value >= 100;
2013-05-08 01:17:41 +00:00
}
2013-02-21 01:33:05 +00:00
}
private int GetChildCount(Folder folder, User user)
{
return folder.GetChildren(user, true)
.Count();
}
2013-09-17 02:44:06 +00:00
public UserDto GetUserDto(User user)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
if (user == null)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
throw new ArgumentNullException("user");
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
var dto = new UserDto
2013-03-20 14:06:22 +00:00
{
2013-09-04 17:02:19 +00:00
Id = user.Id.ToString("N"),
Name = user.Name,
HasPassword = !String.IsNullOrEmpty(user.Password),
LastActivityDate = user.LastActivityDate,
LastLoginDate = user.LastLoginDate,
Configuration = user.Configuration
};
2013-02-21 01:33:05 +00:00
2014-02-07 20:30:41 +00:00
var image = user.GetImageInfo(ImageType.Primary, 0);
2014-02-07 20:30:41 +00:00
if (image != null)
2013-02-21 01:33:05 +00:00
{
2014-02-07 20:30:41 +00:00
dto.PrimaryImageTag = GetImageCacheTag(user, image);
2013-09-04 17:02:19 +00:00
try
{
2013-09-17 02:44:06 +00:00
AttachPrimaryImageAspectRatio(dto, user);
}
catch (Exception ex)
{
2013-09-04 17:02:19 +00:00
// 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);
}
2013-09-04 17:02:19 +00:00
}
2013-09-04 17:02:19 +00:00
return dto;
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
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,
CanSeek = session.CanSeek,
QueueableMediaTypes = session.QueueableMediaTypes,
PlayableMediaTypes = session.PlayableMediaTypes,
RemoteEndPoint = session.RemoteEndPoint,
2014-01-04 02:59:20 +00:00
AdditionalUsers = session.AdditionalUsers
2013-09-04 17:02:19 +00:00
};
2013-09-04 17:02:19 +00:00
if (session.NowPlayingItem != null)
{
2013-09-04 17:02:19 +00:00
dto.NowPlayingItem = GetBaseItemInfo(session.NowPlayingItem);
2013-02-21 01:33:05 +00:00
}
if (session.UserId.HasValue)
2013-09-04 17:02:19 +00:00
{
dto.UserId = session.UserId.Value.ToString("N");
2013-09-04 17:02:19 +00:00
}
dto.UserName = session.UserName;
2013-09-04 17:02:19 +00:00
return dto;
2013-02-21 01:33:05 +00:00
}
/// <summary>
2013-09-04 17:02:19 +00:00
/// Converts a BaseItem to a BaseItemInfo
2013-02-21 01:33:05 +00:00
/// </summary>
/// <param name="item">The item.</param>
2013-09-04 17:02:19 +00:00
/// <returns>BaseItemInfo.</returns>
/// <exception cref="System.ArgumentNullException">item</exception>
public BaseItemInfo GetBaseItemInfo(BaseItem item)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
if (item == null)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
throw new ArgumentNullException("item");
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
var info = new BaseItemInfo
{
2013-09-04 17:02:19 +00:00
Id = GetDtoId(item),
Name = item.Name,
MediaType = item.MediaType,
2013-11-21 20:48:26 +00:00
Type = item.GetClientTypeName(),
2013-09-04 17:02:19 +00:00
RunTimeTicks = item.RunTimeTicks
};
2013-02-21 01:33:05 +00:00
2014-02-07 20:30:41 +00:00
info.PrimaryImageTag = GetImageCacheTag(item, ImageType.Primary);
2013-09-04 17:02:19 +00:00
return info;
}
2013-09-04 17:02:19 +00:00
/// <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)
{
2013-09-04 17:02:19 +00:00
throw new ArgumentNullException("item");
}
2013-09-04 17:02:19 +00:00
return item.Id.ToString("N");
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
/// <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)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
throw new ArgumentNullException("data");
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
return new UserItemDataDto
{
2013-09-04 17:02:19 +00:00
IsFavorite = data.IsFavorite,
Likes = data.Likes,
PlaybackPositionTicks = data.PlaybackPositionTicks,
PlayCount = data.PlayCount,
Rating = data.Rating,
Played = data.Played,
LastPlayedDate = data.LastPlayedDate,
Key = data.Key
2013-09-04 17:02:19 +00:00
};
}
private void SetBookProperties(BaseItemDto dto, Book item)
{
dto.SeriesName = item.SeriesName;
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
private void SetMusicVideoProperties(BaseItemDto dto, MusicVideo item)
{
if (!string.IsNullOrEmpty(item.Album))
{
var parentAlbum = _libraryManager.RootFolder
2013-09-27 12:24:28 +00:00
.GetRecursiveChildren(i => i is MusicAlbum)
2013-09-04 17:02:19 +00:00
.FirstOrDefault(i => string.Equals(i.Name, item.Album, StringComparison.OrdinalIgnoreCase));
2013-09-04 17:02:19 +00:00
if (parentAlbum != null)
{
2013-09-04 17:02:19 +00:00
dto.AlbumId = GetDtoId(parentAlbum);
}
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
dto.Album = item.Album;
2013-09-11 17:54:59 +00:00
dto.Artists = string.IsNullOrEmpty(item.Artist) ? new List<string>() : new List<string> { item.Artist };
2013-09-04 17:02:19 +00:00
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
private void SetGameProperties(BaseItemDto dto, Game item)
{
dto.Players = item.PlayersSupported;
dto.GameSystem = item.GameSystem;
}
2013-02-21 01:33:05 +00:00
2013-10-27 21:40:42 +00:00
private void SetGameSystemProperties(BaseItemDto dto, GameSystem item)
{
dto.GameSystem = item.GameSystemName;
}
2013-09-04 17:02:19 +00:00
/// <summary>
/// Gets the backdrop image tags.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>List{System.String}.</returns>
private List<Guid> GetBackdropImageTags(BaseItem item)
{
2014-02-07 20:30:41 +00:00
return GetCacheTags(item, ImageType.Backdrop).ToList();
2013-09-04 17:02:19 +00:00
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
/// <summary>
/// Gets the screenshot image tags.
/// </summary>
/// <param name="item">The item.</param>
/// <returns>List{Guid}.</returns>
private List<Guid> GetScreenshotImageTags(BaseItem item)
{
var hasScreenshots = item as IHasScreenshots;
if (hasScreenshots == null)
{
return new List<Guid>();
}
2014-02-07 20:30:41 +00:00
return GetCacheTags(item, ImageType.Screenshot).ToList();
}
2014-02-07 20:30:41 +00:00
private IEnumerable<Guid> GetCacheTags(BaseItem item, ImageType type)
{
return item.GetImages(type)
.Select(p => GetImageCacheTag(item, p))
2013-09-04 17:02:19 +00:00
.Where(i => i.HasValue)
.Select(i => i.Value)
.ToList();
}
2014-02-07 20:30:41 +00:00
private Guid? GetImageCacheTag(BaseItem item, ImageType type)
{
try
{
return _imageProcessor.GetImageCacheTag(item, type);
}
catch (IOException ex)
{
_logger.ErrorException("Error getting {0} image info", ex, type);
return null;
}
}
private Guid? GetImageCacheTag(BaseItem item, ItemImageInfo image)
2013-09-04 17:02:19 +00:00
{
try
2013-02-21 01:33:05 +00:00
{
2014-02-07 20:30:41 +00:00
return _imageProcessor.GetImageCacheTag(item, image);
}
2013-09-04 17:02:19 +00:00
catch (IOException ex)
2013-02-21 01:33:05 +00:00
{
2014-02-07 20:30:41 +00:00
_logger.ErrorException("Error getting {0} image info for {1}", ex, image.Type, image.Path);
2013-09-04 17:02:19 +00:00
return null;
2013-02-21 01:33:05 +00:00
}
}
/// <summary>
2013-09-04 17:02:19 +00:00
/// Attaches People DTO's to a DTOBaseItem
/// </summary>
/// <param name="dto">The dto.</param>
/// <param name="item">The item.</param>
/// <returns>Task.</returns>
private void AttachPeople(BaseItemDto dto, BaseItem item)
2013-09-04 17:02:19 +00:00
{
// 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.SortOrder ?? int.MaxValue).ThenBy(i => i.Type).ToList();
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
// Attach People by transforming them into BaseItemPerson (DTO)
dto.People = new BaseItemPerson[people.Count];
2013-02-21 01:33:05 +00:00
var dictionary = people.Select(p => p.Name)
2013-09-04 17:02:19 +00:00
.Distinct(StringComparer.OrdinalIgnoreCase).Select(c =>
{
try
{
return _libraryManager.GetPerson(c);
}
catch (IOException ex)
2013-09-04 17:02:19 +00:00
{
_logger.ErrorException("Error getting person {0}", ex, c);
return null;
}
}).Where(i => i != null)
2013-09-04 17:02:19 +00:00
.DistinctBy(i => i.Name)
.ToDictionary(i => i.Name, StringComparer.OrdinalIgnoreCase);
for (var i = 0; i < people.Count; i++)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
var person = people[i];
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
var baseItemPerson = new BaseItemPerson
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
Name = person.Name,
Role = person.Role,
Type = person.Type
};
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
Person entity;
if (dictionary.TryGetValue(person.Name, out entity))
{
2014-02-07 20:30:41 +00:00
baseItemPerson.PrimaryImageTag = GetImageCacheTag(entity, ImageType.Primary);
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
dto.People[i] = baseItemPerson;
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
/// <summary>
/// Attaches the studios.
/// </summary>
/// <param name="dto">The dto.</param>
/// <param name="item">The item.</param>
/// <returns>Task.</returns>
private void AttachStudios(BaseItemDto dto, BaseItem item)
2013-09-04 17:02:19 +00:00
{
var studios = item.Studios.ToList();
dto.Studios = new StudioDto[studios.Count];
var dictionary = studios.Distinct(StringComparer.OrdinalIgnoreCase).Select(name =>
{
try
{
return _libraryManager.GetStudio(name);
}
catch (IOException ex)
{
_logger.ErrorException("Error getting studio {0}", ex, name);
return null;
}
})
.Where(i => i != null)
.ToDictionary(i => i.Name, StringComparer.OrdinalIgnoreCase);
2013-09-04 17:02:19 +00:00
for (var i = 0; i < studios.Count; i++)
2013-07-08 19:31:45 +00:00
{
2013-09-04 17:02:19 +00:00
var studio = studios[i];
2013-07-08 19:31:45 +00:00
2013-09-04 17:02:19 +00:00
var studioDto = new StudioDto
2013-07-08 19:31:45 +00:00
{
2013-09-04 17:02:19 +00:00
Name = studio
};
2013-07-08 19:31:45 +00:00
2013-09-04 17:02:19 +00:00
Studio entity;
if (dictionary.TryGetValue(studio, out entity))
{
2014-02-07 20:30:41 +00:00
studioDto.PrimaryImageTag = GetImageCacheTag(entity, ImageType.Primary);
2013-07-08 19:31:45 +00:00
}
2013-09-04 17:02:19 +00:00
dto.Studios[i] = studioDto;
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
/// <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;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
while (parent != null)
2013-02-21 01:33:05 +00:00
{
2014-02-07 20:30:41 +00:00
if (parent.GetImages(ImageType.Backdrop).Any())
2013-09-04 17:02:19 +00:00
{
return parent;
}
parent = parent.Parent;
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
return null;
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
/// <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)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
if (parent.HasImage(type))
{
return parent;
}
parent = parent.Parent;
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
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
{
2013-09-04 17:02:19 +00:00
Name = chapterInfo.Name,
StartPositionTicks = chapterInfo.StartPositionTicks
};
2013-09-04 17:02:19 +00:00
if (!string.IsNullOrEmpty(chapterInfo.ImagePath))
2013-02-21 01:33:05 +00:00
{
2014-02-07 20:30:41 +00:00
dto.ImageTag = GetImageCacheTag(item, new ItemImageInfo
{
Path = chapterInfo.ImagePath,
Type = ImageType.Chapter,
DateModified = _fileSystem.GetLastWriteTimeUtc(chapterInfo.ImagePath)
});
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
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))
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
throw new ArgumentNullException("id");
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
BaseItem item = null;
2013-07-16 19:10:57 +00:00
2013-12-11 02:51:26 +00:00
if (userId.HasValue)
2013-09-04 17:02:19 +00:00
{
item = _libraryManager.GetItemById(new Guid(id));
}
2013-07-16 19:10:57 +00:00
2013-09-04 17:02:19 +00:00
// If we still don't find it, look within individual user views
2013-12-11 02:51:26 +00:00
if (item == null && !userId.HasValue)
2013-09-04 17:02:19 +00:00
{
foreach (var user in _userManager.Users)
2013-07-16 19:10:57 +00:00
{
2013-09-04 17:02:19 +00:00
item = GetItemByDtoId(id, user.Id);
2013-07-16 19:10:57 +00:00
2013-09-04 17:02:19 +00:00
if (item != null)
2013-07-16 19:10:57 +00:00
{
2013-09-04 17:02:19 +00:00
break;
2013-07-16 19:10:57 +00:00
}
}
2013-07-16 16:03:28 +00:00
}
2013-04-24 22:34:38 +00:00
2013-09-04 17:02:19 +00:00
return item;
}
2013-04-24 22:34:38 +00:00
2013-09-04 17:02:19 +00:00
/// <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))
2013-05-24 04:02:42 +00:00
{
2013-09-04 17:02:19 +00:00
dto.DateCreated = item.DateCreated;
2013-05-24 04:02:42 +00:00
}
2013-09-04 17:02:19 +00:00
dto.DisplayMediaType = item.DisplayMediaType;
if (fields.Contains(ItemFields.Settings))
2013-09-04 17:02:19 +00:00
{
dto.LockedFields = item.LockedFields;
2014-02-19 05:21:03 +00:00
dto.LockData = item.DontFetchMeta;
2013-07-16 16:03:28 +00:00
}
2013-02-21 01:33:05 +00:00
2013-12-02 16:16:03 +00:00
var hasBudget = item as IHasBudget;
if (hasBudget != null)
2013-07-16 16:03:28 +00:00
{
2013-12-02 16:16:03 +00:00
if (fields.Contains(ItemFields.Budget))
{
dto.Budget = hasBudget.Budget;
}
2013-02-21 01:33:05 +00:00
2013-12-02 16:16:03 +00:00
if (fields.Contains(ItemFields.Revenue))
{
dto.Revenue = hasBudget.Revenue;
}
2013-02-21 01:33:05 +00:00
}
2013-04-24 22:34:38 +00:00
2013-09-04 17:02:19 +00:00
dto.EndDate = item.EndDate;
2013-04-24 22:34:38 +00:00
2013-09-04 17:02:19 +00:00
if (fields.Contains(ItemFields.HomePageUrl))
2013-04-24 22:34:38 +00:00
{
2013-09-04 17:02:19 +00:00
dto.HomePageUrl = item.HomePageUrl;
2013-04-24 22:34:38 +00:00
}
2013-07-12 19:56:40 +00:00
2013-09-04 17:02:19 +00:00
if (fields.Contains(ItemFields.Tags))
{
var hasTags = item as IHasTags;
if (hasTags != null)
{
dto.Tags = hasTags.Tags;
}
if (dto.Tags == null)
{
dto.Tags = new List<string>();
}
2013-09-04 17:02:19 +00:00
}
2013-07-12 19:56:40 +00:00
2014-01-14 15:50:39 +00:00
if (fields.Contains(ItemFields.Keywords))
{
2014-02-07 20:30:41 +00:00
var hasTags = item as IHasKeywords;
2014-01-14 15:50:39 +00:00
if (hasTags != null)
{
dto.Keywords = hasTags.Keywords;
}
if (dto.Keywords == null)
{
dto.Keywords = new List<string>();
}
}
2013-09-04 17:02:19 +00:00
if (fields.Contains(ItemFields.ProductionLocations))
2013-07-12 19:56:40 +00:00
{
SetProductionLocations(item, dto);
2013-07-12 19:56:40 +00:00
}
2013-08-30 23:55:17 +00:00
var hasAspectRatio = item as IHasAspectRatio;
if (hasAspectRatio != null)
{
dto.AspectRatio = hasAspectRatio.AspectRatio;
}
2013-08-30 23:55:17 +00:00
2014-01-15 05:01:58 +00:00
var hasMetascore = item as IHasMetascore;
if (hasMetascore != null)
{
dto.Metascore = hasMetascore.Metascore;
}
if (fields.Contains(ItemFields.AwardSummary))
{
var hasAwards = item as IHasAwards;
if (hasAwards != null)
{
dto.AwardSummary = hasAwards.AwardSummary;
}
}
2013-09-04 17:02:19 +00:00
dto.BackdropImageTags = GetBackdropImageTags(item);
2013-09-18 02:43:34 +00:00
if (fields.Contains(ItemFields.ScreenshotImageTags))
{
dto.ScreenshotImageTags = GetScreenshotImageTags(item);
}
2013-09-04 17:02:19 +00:00
if (fields.Contains(ItemFields.Genres))
2013-08-30 23:55:17 +00:00
{
2013-09-04 17:02:19 +00:00
dto.Genres = item.Genres;
2013-08-30 23:55:17 +00:00
}
2013-07-12 19:56:40 +00:00
2013-09-04 17:02:19 +00:00
dto.ImageTags = new Dictionary<ImageType, Guid>();
2014-02-07 20:30:41 +00:00
// Prevent implicitly captured closure
var currentItem = item;
foreach (var image in currentItem.ImageInfos.Where(i => !currentItem.AllowsMultipleImages(i.Type)))
{
2014-02-07 20:30:41 +00:00
var tag = GetImageCacheTag(item, image);
2013-09-04 17:02:19 +00:00
if (tag.HasValue)
{
2014-02-07 20:30:41 +00:00
dto.ImageTags[image.Type] = tag.Value;
}
}
2013-09-04 17:02:19 +00:00
dto.Id = GetDtoId(item);
dto.IndexNumber = item.IndexNumber;
dto.IsFolder = item.IsFolder;
dto.MediaType = item.MediaType;
dto.LocationType = item.LocationType;
2013-09-11 17:54:59 +00:00
2013-12-28 16:58:13 +00:00
var hasLang = item as IHasPreferredMetadataLanguage;
if (hasLang != null)
{
2013-12-28 16:58:13 +00:00
dto.PreferredMetadataCountryCode = hasLang.PreferredMetadataCountryCode;
dto.PreferredMetadataLanguage = hasLang.PreferredMetadataLanguage;
}
2013-11-06 16:06:16 +00:00
var hasCriticRating = item as IHasCriticRating;
if (hasCriticRating != null)
2013-09-04 17:02:19 +00:00
{
2013-11-06 16:06:16 +00:00
dto.CriticRating = hasCriticRating.CriticRating;
if (fields.Contains(ItemFields.CriticRatingSummary))
{
dto.CriticRatingSummary = hasCriticRating.CriticRatingSummary;
}
2013-09-04 17:02:19 +00:00
}
2013-02-21 01:33:05 +00:00
2013-12-02 16:46:25 +00:00
var hasTrailers = item as IHasTrailers;
if (hasTrailers != null)
{
dto.LocalTrailerCount = hasTrailers.LocalTrailerIds.Count;
}
2013-02-21 01:33:05 +00:00
var hasDisplayOrder = item as IHasDisplayOrder;
if (hasDisplayOrder != null)
{
dto.DisplayOrder = hasDisplayOrder.DisplayOrder;
}
var collectionFolder = item as CollectionFolder;
if (collectionFolder != null)
{
dto.CollectionType = collectionFolder.CollectionType;
}
2014-02-07 20:30:41 +00:00
2013-12-02 16:46:25 +00:00
if (fields.Contains(ItemFields.RemoteTrailers))
2013-02-21 01:33:05 +00:00
{
2013-12-02 16:46:25 +00:00
dto.RemoteTrailers = hasTrailers != null ?
hasTrailers.RemoteTrailers :
new List<MediaUrl>();
2013-09-04 17:02:19 +00:00
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
dto.Name = item.Name;
dto.OfficialRating = item.OfficialRating;
2013-03-09 05:15:51 +00:00
2013-09-04 17:02:19 +00:00
var hasOverview = fields.Contains(ItemFields.Overview);
var hasHtmlOverview = fields.Contains(ItemFields.OverviewHtml);
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
if (hasOverview || hasHtmlOverview)
{
var strippedOverview = string.IsNullOrEmpty(item.Overview) ? item.Overview : item.Overview.StripHtml();
2013-06-08 17:04:17 +00:00
2013-09-04 17:02:19 +00:00
if (hasOverview)
2013-03-09 05:15:51 +00:00
{
2013-09-04 17:02:19 +00:00
dto.Overview = strippedOverview;
2013-02-21 01:33:05 +00:00
}
2013-06-08 17:04:17 +00:00
2013-09-04 17:02:19 +00:00
// Only supply the html version if there was actually html content
if (hasHtmlOverview)
2013-06-08 17:04:17 +00:00
{
2013-09-04 17:02:19 +00:00
dto.OverviewHtml = item.Overview;
2013-06-08 17:04:17 +00:00
}
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
// If there are no backdrops, indicate what parent has them in case the Ui wants to allow inheritance
if (dto.BackdropImageTags.Count == 0)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
var parentWithBackdrop = GetParentBackdropItem(item, owner);
if (parentWithBackdrop != null)
{
dto.ParentBackdropItemId = GetDtoId(parentWithBackdrop);
dto.ParentBackdropImageTags = GetBackdropImageTags(parentWithBackdrop);
}
2013-02-21 01:33:05 +00:00
}
2013-07-25 19:17:44 +00:00
2013-09-04 17:02:19 +00:00
if (item.Parent != null && fields.Contains(ItemFields.ParentId))
2013-07-25 19:17:44 +00:00
{
2013-09-04 17:02:19 +00:00
dto.ParentId = GetDtoId(item.Parent);
2013-07-25 19:17:44 +00:00
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
dto.ParentIndexNumber = item.ParentIndexNumber;
2013-09-04 17:02:19 +00:00
// If there is no logo, indicate what parent has one in case the Ui wants to allow inheritance
if (!dto.HasLogo)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
var parentWithLogo = GetParentImageItem(item, ImageType.Logo, owner);
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
if (parentWithLogo != null)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
dto.ParentLogoItemId = GetDtoId(parentWithLogo);
2013-02-21 01:33:05 +00:00
2014-02-07 20:30:41 +00:00
dto.ParentLogoImageTag = GetImageCacheTag(parentWithLogo, ImageType.Logo);
2013-09-04 17:02:19 +00:00
}
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
// 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)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
dto.ParentArtItemId = GetDtoId(parentWithImage);
2013-02-21 01:33:05 +00:00
2014-02-07 20:30:41 +00:00
dto.ParentArtImageTag = GetImageCacheTag(parentWithImage, ImageType.Art);
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
}
2013-02-21 01:33:05 +00:00
2013-10-24 17:49:24 +00:00
// If there is no thumb, indicate what parent has one in case the Ui wants to allow inheritance
if (!dto.HasThumb)
{
var parentWithImage = GetParentImageItem(item, ImageType.Thumb, owner);
if (parentWithImage != null)
{
dto.ParentThumbItemId = GetDtoId(parentWithImage);
2014-02-07 20:30:41 +00:00
dto.ParentThumbImageTag = GetImageCacheTag(parentWithImage, ImageType.Thumb);
2013-10-24 17:49:24 +00:00
}
}
2013-09-04 17:02:19 +00:00
if (fields.Contains(ItemFields.Path))
{
2014-02-14 04:00:13 +00:00
var locationType = item.LocationType;
if (locationType != LocationType.Remote && locationType != LocationType.Virtual)
2014-02-14 04:00:13 +00:00
{
dto.Path = GetMappedPath(item.Path);
}
else
{
dto.Path = item.Path;
}
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
dto.PremiereDate = item.PremiereDate;
dto.ProductionYear = item.ProductionYear;
2013-05-04 03:13:28 +00:00
2013-09-04 17:02:19 +00:00
if (fields.Contains(ItemFields.ProviderIds))
{
dto.ProviderIds = item.ProviderIds;
}
2013-05-04 03:13:28 +00:00
2013-09-04 17:02:19 +00:00
dto.RunTimeTicks = item.RunTimeTicks;
2013-05-04 03:13:28 +00:00
2013-09-04 17:02:19 +00:00
if (fields.Contains(ItemFields.SortName))
{
dto.SortName = item.SortName;
}
2013-05-04 03:13:28 +00:00
2013-09-04 17:02:19 +00:00
if (fields.Contains(ItemFields.CustomRating))
{
dto.CustomRating = item.CustomRating;
}
2013-05-04 03:13:28 +00:00
2013-09-04 17:02:19 +00:00
if (fields.Contains(ItemFields.Taglines))
{
var hasTagline = item as IHasTaglines;
if (hasTagline != null)
{
dto.Taglines = hasTagline.Taglines;
}
if (dto.Taglines == null)
{
dto.Taglines = new List<string>();
}
2013-09-04 17:02:19 +00:00
}
2013-05-04 03:13:28 +00:00
2013-11-21 20:48:26 +00:00
dto.Type = item.GetClientTypeName();
2013-09-04 17:02:19 +00:00
dto.CommunityRating = item.CommunityRating;
dto.VoteCount = item.VoteCount;
2013-05-04 03:13:28 +00:00
2013-09-04 17:02:19 +00:00
if (item.IsFolder)
{
var folder = (Folder)item;
2013-05-04 03:13:28 +00:00
2013-09-04 17:02:19 +00:00
if (fields.Contains(ItemFields.IndexOptions))
2013-05-04 03:13:28 +00:00
{
2013-09-04 17:02:19 +00:00
dto.IndexOptions = folder.IndexByOptionStrings.ToArray();
2013-05-04 03:13:28 +00:00
}
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
// Add audio info
var audio = item as Audio;
if (audio != null)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
dto.Album = audio.Album;
2013-09-11 17:54:59 +00:00
dto.Artists = audio.Artists;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
var albumParent = audio.FindParent<MusicAlbum>();
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
if (albumParent != null)
{
dto.AlbumId = GetDtoId(albumParent);
2013-02-21 01:33:05 +00:00
2014-02-07 20:30:41 +00:00
dto.AlbumPrimaryImageTag = GetImageCacheTag(albumParent, ImageType.Primary);
2013-02-21 01:33:05 +00:00
}
}
2013-09-04 17:02:19 +00:00
var album = item as MusicAlbum;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
if (album != null)
2013-02-21 01:33:05 +00:00
{
dto.Artists = album.Artists;
2013-11-12 15:36:08 +00:00
dto.SoundtrackIds = album.SoundtrackIds
.Select(i => i.ToString("N"))
.ToArray();
2013-09-04 17:02:19 +00:00
}
2013-02-21 01:33:05 +00:00
var hasAlbumArtist = item as IHasAlbumArtist;
if (hasAlbumArtist != null)
{
dto.AlbumArtist = hasAlbumArtist.AlbumArtist;
}
2013-09-04 17:02:19 +00:00
// Add video info
var video = item as Video;
if (video != null)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
dto.VideoType = video.VideoType;
dto.Video3DFormat = video.Video3DFormat;
dto.IsoType = video.IsoType;
dto.IsHD = video.IsHD;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
dto.PartCount = video.AdditionalPartIds.Count + 1;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
if (fields.Contains(ItemFields.Chapters))
{
dto.Chapters = _itemRepo.GetChapters(video.Id).Select(c => GetChapterInfoDto(c, item)).ToList();
}
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
if (fields.Contains(ItemFields.MediaStreams))
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
// Add VideoInfo
var iHasMediaStreams = item as IHasMediaStreams;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
if (iHasMediaStreams != null)
{
2013-12-06 03:39:44 +00:00
dto.MediaStreams = _itemRepo.GetMediaStreams(new MediaStreamQuery
{
ItemId = item.Id
}).ToList();
2013-09-04 17:02:19 +00:00
}
}
// Add MovieInfo
var movie = item as Movie;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
if (movie != null)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
var specialFeatureCount = movie.SpecialFeatureIds.Count;
if (specialFeatureCount > 0)
{
2013-09-04 17:02:19 +00:00
dto.SpecialFeatureCount = specialFeatureCount;
}
if (fields.Contains(ItemFields.TmdbCollectionName))
{
dto.TmdbCollectionName = movie.TmdbCollectionName;
}
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
// Add EpisodeInfo
var episode = item as Episode;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
if (episode != null)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
dto.IndexNumberEnd = episode.IndexNumberEnd;
dto.DvdSeasonNumber = episode.DvdSeasonNumber;
dto.DvdEpisodeNumber = episode.DvdEpisodeNumber;
dto.AirsAfterSeasonNumber = episode.AirsAfterSeasonNumber;
dto.AirsBeforeEpisodeNumber = episode.AirsBeforeEpisodeNumber;
dto.AirsBeforeSeasonNumber = episode.AirsBeforeSeasonNumber;
dto.AbsoluteEpisodeNumber = episode.AbsoluteEpisodeNumber;
var seasonId = episode.SeasonId;
if (seasonId.HasValue)
{
dto.SeasonId = seasonId.Value.ToString("N");
}
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
// Add SeriesInfo
var series = item as Series;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
if (series != null)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
dto.AirDays = series.AirDays;
dto.AirTime = series.AirTime;
dto.Status = series.Status;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
dto.SpecialFeatureCount = series.SpecialFeatureIds.Count;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
dto.SeasonCount = series.SeasonCount;
if (fields.Contains(ItemFields.Settings))
{
dto.DisplaySpecialsWithSeasons = series.DisplaySpecialsWithSeasons;
}
2013-09-04 17:02:19 +00:00
}
if (episode != null)
{
2013-09-04 17:02:19 +00:00
series = item.FindParent<Series>();
dto.SeriesId = GetDtoId(series);
dto.SeriesName = series.Name;
2013-10-24 17:49:24 +00:00
dto.AirTime = series.AirTime;
dto.SeriesStudio = series.Studios.FirstOrDefault();
2014-02-07 20:30:41 +00:00
dto.SeriesThumbImageTag = GetImageCacheTag(series, ImageType.Thumb);
2013-11-09 18:44:09 +00:00
2014-02-07 20:30:41 +00:00
dto.SeriesPrimaryImageTag = GetImageCacheTag(series, ImageType.Primary);
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
// Add SeasonInfo
var season = item as Season;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
if (season != null)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
series = item.FindParent<Series>();
dto.SeriesId = GetDtoId(series);
dto.SeriesName = series.Name;
2013-10-24 17:49:24 +00:00
dto.AirTime = series.AirTime;
dto.SeriesStudio = series.Studios.FirstOrDefault();
2013-11-09 18:44:09 +00:00
2014-02-07 20:30:41 +00:00
dto.SeriesPrimaryImageTag = GetImageCacheTag(series, ImageType.Primary);
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
var game = item as Game;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
if (game != null)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
SetGameProperties(dto, game);
2013-02-21 01:33:05 +00:00
}
2013-10-27 21:40:42 +00:00
var gameSystem = item as GameSystem;
if (gameSystem != null)
{
SetGameSystemProperties(dto, gameSystem);
}
2013-09-04 17:02:19 +00:00
var musicVideo = item as MusicVideo;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
if (musicVideo != null)
{
SetMusicVideoProperties(dto, musicVideo);
2013-02-21 01:33:05 +00:00
}
2013-09-04 17:02:19 +00:00
var book = item as Book;
if (book != null)
{
SetBookProperties(dto, book);
}
2013-02-21 01:33:05 +00:00
}
2014-02-14 04:00:13 +00:00
private string GetMappedPath(string path)
2014-01-30 05:20:18 +00:00
{
2014-02-14 04:00:13 +00:00
foreach (var map in _config.Configuration.PathSubstitutions)
2014-01-30 05:20:18 +00:00
{
2014-02-14 04:00:13 +00:00
path = _fileSystem.SubstitutePath(path, map.From, map.To);
2014-01-30 05:20:18 +00:00
}
return path;
}
private void SetProductionLocations(BaseItem item, BaseItemDto dto)
{
var hasProductionLocations = item as IHasProductionLocations;
if (hasProductionLocations != null)
{
dto.ProductionLocations = hasProductionLocations.ProductionLocations;
}
var person = item as Person;
if (person != null)
{
dto.ProductionLocations = new List<string>();
if (!string.IsNullOrEmpty(person.PlaceOfBirth))
{
dto.ProductionLocations.Add(person.PlaceOfBirth);
}
}
if (dto.ProductionLocations == null)
{
dto.ProductionLocations = new List<string>();
}
}
2013-02-21 01:33:05 +00:00
/// <summary>
2013-09-04 17:02:19 +00:00
/// Since it can be slow to make all of these calculations independently, this method will provide a way to do them all at once
2013-02-21 01:33:05 +00:00
/// </summary>
2013-09-04 17:02:19 +00:00
/// <param name="folder">The folder.</param>
/// <param name="user">The user.</param>
/// <param name="dto">The dto.</param>
/// <param name="fields">The fields.</param>
2013-09-04 17:02:19 +00:00
/// <returns>Task.</returns>
private void SetSpecialCounts(Folder folder, User user, BaseItemDto dto, List<ItemFields> fields)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
var rcentlyAddedItemCount = 0;
var recursiveItemCount = 0;
var unplayed = 0;
long runtime = 0;
2013-02-21 01:33:05 +00:00
2014-02-10 18:43:33 +00:00
DateTime? dateLastMediaAdded = null;
2013-09-04 17:02:19 +00:00
double totalPercentPlayed = 0;
2013-02-21 01:33:05 +00:00
IEnumerable<BaseItem> children;
var season = folder as Season;
if (season != null)
{
children = season.GetEpisodes(user).Where(i => i.LocationType != LocationType.Virtual);
}
else
{
children = folder.GetRecursiveChildren(user, i => !i.IsFolder && i.LocationType != LocationType.Virtual);
}
2013-09-04 17:02:19 +00:00
// Loop through each recursive child
foreach (var child in children)
2013-09-04 17:02:19 +00:00
{
2014-02-10 18:43:33 +00:00
if (!dateLastMediaAdded.HasValue)
{
dateLastMediaAdded = child.DateCreated;
}
else
{
dateLastMediaAdded = new[] { dateLastMediaAdded.Value, child.DateCreated }.Max();
}
2013-09-04 17:02:19 +00:00
var userdata = _userDataRepository.GetUserData(user.Id, child.GetUserDataKey());
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
recursiveItemCount++;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
// Check is recently added
if (child.IsRecentlyAdded())
{
rcentlyAddedItemCount++;
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
var isUnplayed = true;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
// Incrememt totalPercentPlayed
if (userdata != null)
{
if (userdata.Played)
{
totalPercentPlayed += 100;
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
isUnplayed = false;
}
else if (userdata.PlaybackPositionTicks > 0 && child.RunTimeTicks.HasValue && child.RunTimeTicks.Value > 0)
{
double itemPercent = userdata.PlaybackPositionTicks;
itemPercent /= child.RunTimeTicks.Value;
totalPercentPlayed += itemPercent;
}
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
if (isUnplayed)
{
unplayed++;
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
runtime += child.RunTimeTicks ?? 0;
}
2013-02-21 01:33:05 +00:00
2013-09-04 17:02:19 +00:00
dto.RecursiveItemCount = recursiveItemCount;
dto.RecentlyAddedItemCount = rcentlyAddedItemCount;
dto.RecursiveUnplayedItemCount = unplayed;
if (recursiveItemCount > 0)
2013-02-21 01:33:05 +00:00
{
2013-09-04 17:02:19 +00:00
dto.PlayedPercentage = totalPercentPlayed / recursiveItemCount;
2013-02-21 01:33:05 +00:00
}
if (runtime > 0 && fields.Contains(ItemFields.CumulativeRunTimeTicks))
2013-09-04 17:02:19 +00:00
{
dto.CumulativeRunTimeTicks = runtime;
}
2014-02-10 18:43:33 +00:00
if (fields.Contains(ItemFields.DateLastMediaAdded))
{
dto.DateLastMediaAdded = dateLastMediaAdded;
}
2013-02-21 01:33:05 +00:00
}
/// <summary>
2013-09-04 17:02:19 +00:00
/// Attaches the primary image aspect ratio.
2013-02-21 01:33:05 +00:00
/// </summary>
2013-09-04 17:02:19 +00:00
/// <param name="dto">The dto.</param>
2013-02-21 01:33:05 +00:00
/// <param name="item">The item.</param>
2013-09-04 17:02:19 +00:00
/// <returns>Task.</returns>
2014-01-14 20:03:35 +00:00
public void AttachPrimaryImageAspectRatio(IItemDto dto, IHasImages item)
2013-02-21 01:33:05 +00:00
{
2014-02-07 20:30:41 +00:00
var imageInfo = item.GetImageInfo(ImageType.Primary, 0);
2013-05-05 04:49:49 +00:00
2014-02-07 20:30:41 +00:00
if (imageInfo == null)
2013-09-04 17:02:19 +00:00
{
return;
}
2014-02-07 20:30:41 +00:00
var path = imageInfo.Path;
2013-09-04 17:02:19 +00:00
// See if we can avoid a file system lookup by looking for the file in ResolveArgs
2014-02-07 20:30:41 +00:00
var dateModified = imageInfo.DateModified;
2013-09-04 17:02:19 +00:00
ImageSize size;
try
2013-05-05 04:49:49 +00:00
{
2013-09-18 18:49:06 +00:00
size = _imageProcessor.GetImageSize(path, dateModified);
}
2013-09-04 17:02:19 +00:00
catch (FileNotFoundException)
{
2013-09-04 17:02:19 +00:00
_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;
2013-09-18 18:49:06 +00:00
var supportedEnhancers = _imageProcessor.GetSupportedEnhancers(item, ImageType.Primary).ToList();
2013-09-04 17:02:19 +00:00
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);
}
2013-05-05 04:49:49 +00:00
}
2013-09-04 17:02:19 +00:00
dto.PrimaryImageAspectRatio = size.Width / size.Height;
2013-05-05 04:49:49 +00:00
}
2013-02-21 01:33:05 +00:00
}
}