2014-10-23 21:54:35 -07:00
|
|
|
|
using MediaBrowser.Common;
|
|
|
|
|
using MediaBrowser.Common.IO;
|
2014-05-17 14:23:48 -07:00
|
|
|
|
using MediaBrowser.Controller.Channels;
|
2014-01-29 22:20:18 -07:00
|
|
|
|
using MediaBrowser.Controller.Configuration;
|
2015-01-24 12:03:55 -07:00
|
|
|
|
using MediaBrowser.Controller.Devices;
|
2013-09-18 11:49:06 -07:00
|
|
|
|
using MediaBrowser.Controller.Drawing;
|
2013-09-04 10:02:19 -07:00
|
|
|
|
using MediaBrowser.Controller.Dto;
|
2013-03-12 15:49:45 -07:00
|
|
|
|
using MediaBrowser.Controller.Entities;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
using MediaBrowser.Controller.Entities.Audio;
|
|
|
|
|
using MediaBrowser.Controller.Entities.Movies;
|
|
|
|
|
using MediaBrowser.Controller.Entities.TV;
|
2013-04-13 11:02:30 -07:00
|
|
|
|
using MediaBrowser.Controller.Library;
|
2014-03-30 09:49:40 -07:00
|
|
|
|
using MediaBrowser.Controller.LiveTv;
|
2013-04-13 11:02:30 -07:00
|
|
|
|
using MediaBrowser.Controller.Persistence;
|
2014-08-02 19:16:37 -07:00
|
|
|
|
using MediaBrowser.Controller.Playlists;
|
2014-02-21 11:48:15 -07:00
|
|
|
|
using MediaBrowser.Controller.Providers;
|
2014-07-22 09:36:34 -07:00
|
|
|
|
using MediaBrowser.Controller.Sync;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
using MediaBrowser.Model.Drawing;
|
2013-02-21 10:50:46 -07:00
|
|
|
|
using MediaBrowser.Model.Dto;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
using MediaBrowser.Model.Entities;
|
2013-02-20 23:38:23 -07:00
|
|
|
|
using MediaBrowser.Model.Logging;
|
2013-03-12 15:49:45 -07:00
|
|
|
|
using MediaBrowser.Model.Querying;
|
2015-01-24 12:03:55 -07:00
|
|
|
|
using MediaBrowser.Model.Sync;
|
2013-09-04 10:02:19 -07:00
|
|
|
|
using MoreLinq;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
using System;
|
|
|
|
|
using System.Collections.Generic;
|
|
|
|
|
using System.IO;
|
|
|
|
|
using System.Linq;
|
2015-10-03 21:23:11 -07:00
|
|
|
|
using CommonIO;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
namespace MediaBrowser.Server.Implementations.Dto
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
public class DtoService : IDtoService
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-03-01 14:22:34 -07:00
|
|
|
|
private readonly ILogger _logger;
|
2013-03-12 15:49:45 -07:00
|
|
|
|
private readonly ILibraryManager _libraryManager;
|
2013-10-02 09:08:58 -07:00
|
|
|
|
private readonly IUserDataManager _userDataRepository;
|
2013-06-18 12:16:27 -07:00
|
|
|
|
private readonly IItemRepository _itemRepo;
|
2013-02-21 18:26:35 -07:00
|
|
|
|
|
2013-09-18 11:49:06 -07:00
|
|
|
|
private readonly IImageProcessor _imageProcessor;
|
2014-01-29 22:20:18 -07:00
|
|
|
|
private readonly IServerConfigurationManager _config;
|
2014-02-07 13:30:41 -07:00
|
|
|
|
private readonly IFileSystem _fileSystem;
|
2014-02-21 11:48:15 -07:00
|
|
|
|
private readonly IProviderManager _providerManager;
|
2013-10-02 09:08:58 -07:00
|
|
|
|
|
2014-05-19 12:51:56 -07:00
|
|
|
|
private readonly Func<IChannelManager> _channelManagerFactory;
|
2014-07-22 09:36:34 -07:00
|
|
|
|
private readonly ISyncManager _syncManager;
|
2014-10-23 21:54:35 -07:00
|
|
|
|
private readonly IApplicationHost _appHost;
|
2015-01-24 12:03:55 -07:00
|
|
|
|
private readonly Func<IDeviceManager> _deviceManager;
|
2015-03-07 15:43:53 -07:00
|
|
|
|
private readonly Func<IMediaSourceManager> _mediaSourceManager;
|
2015-05-31 11:22:51 -07:00
|
|
|
|
private readonly Func<ILiveTvManager> _livetvManager;
|
2014-05-19 12:51:56 -07:00
|
|
|
|
|
2015-05-31 11:22:51 -07:00
|
|
|
|
public DtoService(ILogger logger, ILibraryManager libraryManager, IUserDataManager userDataRepository, IItemRepository itemRepo, IImageProcessor imageProcessor, IServerConfigurationManager config, IFileSystem fileSystem, IProviderManager providerManager, Func<IChannelManager> channelManagerFactory, ISyncManager syncManager, IApplicationHost appHost, Func<IDeviceManager> deviceManager, Func<IMediaSourceManager> mediaSourceManager, Func<ILiveTvManager> livetvManager)
|
2013-02-21 18:26:35 -07:00
|
|
|
|
{
|
2013-03-01 14:22:34 -07:00
|
|
|
|
_logger = logger;
|
2013-03-12 15:49:45 -07:00
|
|
|
|
_libraryManager = libraryManager;
|
2013-04-13 11:02:30 -07:00
|
|
|
|
_userDataRepository = userDataRepository;
|
2013-06-18 12:16:27 -07:00
|
|
|
|
_itemRepo = itemRepo;
|
2013-09-18 11:49:06 -07:00
|
|
|
|
_imageProcessor = imageProcessor;
|
2014-01-29 22:20:18 -07:00
|
|
|
|
_config = config;
|
2014-02-07 13:30:41 -07:00
|
|
|
|
_fileSystem = fileSystem;
|
2014-02-21 11:48:15 -07:00
|
|
|
|
_providerManager = providerManager;
|
2014-05-19 12:51:56 -07:00
|
|
|
|
_channelManagerFactory = channelManagerFactory;
|
2014-07-22 09:36:34 -07:00
|
|
|
|
_syncManager = syncManager;
|
2014-10-23 21:54:35 -07:00
|
|
|
|
_appHost = appHost;
|
2015-01-24 12:03:55 -07:00
|
|
|
|
_deviceManager = deviceManager;
|
2015-03-07 15:43:53 -07:00
|
|
|
|
_mediaSourceManager = mediaSourceManager;
|
2015-05-31 11:22:51 -07:00
|
|
|
|
_livetvManager = livetvManager;
|
2013-09-16 19:08:18 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-02-20 18:33:05 -07:00
|
|
|
|
/// <summary>
|
2013-05-15 09:56:38 -07:00
|
|
|
|
/// Converts a BaseItem to a DTOBaseItem
|
2013-02-20 18:33:05 -07:00
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
|
/// <param name="fields">The fields.</param>
|
2013-05-15 09:56:38 -07:00
|
|
|
|
/// <param name="user">The user.</param>
|
2013-07-30 07:51:28 -07:00
|
|
|
|
/// <param name="owner">The owner.</param>
|
2013-02-20 18:33:05 -07:00
|
|
|
|
/// <returns>Task{DtoBaseItem}.</returns>
|
|
|
|
|
/// <exception cref="System.ArgumentNullException">item</exception>
|
2013-09-16 19:44:06 -07:00
|
|
|
|
public BaseItemDto GetBaseItemDto(BaseItem item, List<ItemFields> fields, User user = null, BaseItem owner = null)
|
2014-06-28 12:35:30 -07:00
|
|
|
|
{
|
2014-11-30 12:01:33 -07:00
|
|
|
|
var options = new DtoOptions
|
|
|
|
|
{
|
2014-12-20 22:57:06 -07:00
|
|
|
|
Fields = fields
|
2014-11-30 12:01:33 -07:00
|
|
|
|
};
|
2015-01-24 12:03:55 -07:00
|
|
|
|
|
2014-11-30 12:01:33 -07:00
|
|
|
|
return GetBaseItemDto(item, options, user, owner);
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-24 12:03:55 -07:00
|
|
|
|
public IEnumerable<BaseItemDto> GetBaseItemDtos(IEnumerable<BaseItem> items, DtoOptions options, User user = null, BaseItem owner = null)
|
|
|
|
|
{
|
2015-06-02 10:46:44 -07:00
|
|
|
|
var syncJobItems = GetSyncedItemProgress(options);
|
2015-07-12 12:33:00 -07:00
|
|
|
|
var syncDictionary = GetSyncedItemProgressDictionary(syncJobItems);
|
2015-01-24 12:03:55 -07:00
|
|
|
|
|
|
|
|
|
var list = new List<BaseItemDto>();
|
|
|
|
|
|
|
|
|
|
foreach (var item in items)
|
|
|
|
|
{
|
2015-06-02 10:46:44 -07:00
|
|
|
|
var dto = GetBaseItemDtoInternal(item, options, syncDictionary, user, owner);
|
2015-01-24 12:03:55 -07:00
|
|
|
|
|
|
|
|
|
var byName = item as IItemByName;
|
|
|
|
|
|
2015-08-30 21:57:12 -07:00
|
|
|
|
if (byName != null)
|
2015-01-24 12:03:55 -07:00
|
|
|
|
{
|
2015-04-03 19:34:53 -07:00
|
|
|
|
if (options.Fields.Contains(ItemFields.ItemCounts))
|
2015-03-25 21:44:24 -07:00
|
|
|
|
{
|
|
|
|
|
var itemFilter = byName.GetItemFilter();
|
2015-01-26 15:47:16 -07:00
|
|
|
|
|
2015-03-25 21:44:24 -07:00
|
|
|
|
var libraryItems = user != null ?
|
|
|
|
|
user.RootFolder.GetRecursiveChildren(user, itemFilter) :
|
|
|
|
|
_libraryManager.RootFolder.GetRecursiveChildren(itemFilter);
|
2015-01-24 12:03:55 -07:00
|
|
|
|
|
2015-03-25 21:44:24 -07:00
|
|
|
|
SetItemByNameInfo(item, dto, libraryItems.ToList(), user);
|
|
|
|
|
}
|
2015-01-24 12:03:55 -07:00
|
|
|
|
}
|
|
|
|
|
|
2015-06-02 10:46:44 -07:00
|
|
|
|
FillSyncInfo(dto, item, syncJobItems, options, user);
|
2015-01-24 12:03:55 -07:00
|
|
|
|
|
|
|
|
|
list.Add(dto);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return list;
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-12 12:33:00 -07:00
|
|
|
|
private Dictionary<string, SyncedItemProgress> GetSyncedItemProgressDictionary(IEnumerable<SyncedItemProgress> items)
|
|
|
|
|
{
|
|
|
|
|
var dict = new Dictionary<string, SyncedItemProgress>();
|
|
|
|
|
|
|
|
|
|
foreach (var item in items)
|
|
|
|
|
{
|
|
|
|
|
dict[item.ItemId] = item;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return dict;
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-30 12:01:33 -07:00
|
|
|
|
public BaseItemDto GetBaseItemDto(BaseItem item, DtoOptions options, User user = null, BaseItem owner = null)
|
|
|
|
|
{
|
2015-06-02 10:46:44 -07:00
|
|
|
|
var syncProgress = GetSyncedItemProgress(options);
|
|
|
|
|
|
2015-07-12 12:33:00 -07:00
|
|
|
|
var dto = GetBaseItemDtoInternal(item, options, GetSyncedItemProgressDictionary(syncProgress), user, owner);
|
2014-07-27 15:01:29 -07:00
|
|
|
|
|
2014-06-28 12:35:30 -07:00
|
|
|
|
var byName = item as IItemByName;
|
|
|
|
|
|
2015-08-30 21:57:12 -07:00
|
|
|
|
if (byName != null)
|
2014-06-28 12:35:30 -07:00
|
|
|
|
{
|
2015-04-03 19:34:53 -07:00
|
|
|
|
if (options.Fields.Contains(ItemFields.ItemCounts))
|
2015-03-25 21:44:24 -07:00
|
|
|
|
{
|
2015-07-08 09:10:34 -07:00
|
|
|
|
SetItemByNameInfo(item, dto, GetTaggedItems(byName, user), user);
|
2015-03-25 21:44:24 -07:00
|
|
|
|
}
|
2014-06-28 12:35:30 -07:00
|
|
|
|
|
2015-06-02 10:46:44 -07:00
|
|
|
|
FillSyncInfo(dto, item, options, user, syncProgress);
|
2014-06-28 12:35:30 -07:00
|
|
|
|
return dto;
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-02 10:46:44 -07:00
|
|
|
|
FillSyncInfo(dto, item, options, user, syncProgress);
|
2015-01-24 12:03:55 -07:00
|
|
|
|
|
2014-07-27 15:01:29 -07:00
|
|
|
|
return dto;
|
2014-06-28 12:35:30 -07:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-08 09:10:34 -07:00
|
|
|
|
private List<BaseItem> GetTaggedItems(IItemByName byName, User user)
|
|
|
|
|
{
|
|
|
|
|
var person = byName as Person;
|
|
|
|
|
|
|
|
|
|
if (person != null)
|
|
|
|
|
{
|
2015-10-29 06:28:05 -07:00
|
|
|
|
var items = _libraryManager.GetItems(new InternalItemsQuery(user)
|
2015-07-08 09:10:34 -07:00
|
|
|
|
{
|
|
|
|
|
Person = byName.Name
|
|
|
|
|
|
2015-11-11 07:56:31 -07:00
|
|
|
|
}, new string[] { });
|
2015-07-08 09:10:34 -07:00
|
|
|
|
|
|
|
|
|
return items.ToList();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var itemFilter = byName.GetItemFilter();
|
|
|
|
|
|
|
|
|
|
return user != null ?
|
|
|
|
|
user.RootFolder.GetRecursiveChildren(user, itemFilter).ToList() :
|
|
|
|
|
_libraryManager.RootFolder.GetRecursiveChildren(itemFilter).ToList();
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-02 10:46:44 -07:00
|
|
|
|
private SyncedItemProgress[] GetSyncedItemProgress(DtoOptions options)
|
2015-01-24 12:03:55 -07:00
|
|
|
|
{
|
|
|
|
|
if (!options.Fields.Contains(ItemFields.SyncInfo))
|
|
|
|
|
{
|
2015-07-26 22:03:34 -07:00
|
|
|
|
return new SyncedItemProgress[] { };
|
2015-01-24 12:03:55 -07:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var deviceId = options.DeviceId;
|
|
|
|
|
if (string.IsNullOrWhiteSpace(deviceId))
|
|
|
|
|
{
|
2015-06-02 10:46:44 -07:00
|
|
|
|
return new SyncedItemProgress[] { };
|
2015-01-24 12:03:55 -07:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var caps = _deviceManager().GetCapabilities(deviceId);
|
|
|
|
|
if (caps == null || !caps.SupportsSync)
|
|
|
|
|
{
|
2015-06-02 10:46:44 -07:00
|
|
|
|
return new SyncedItemProgress[] { };
|
2015-01-24 12:03:55 -07:00
|
|
|
|
}
|
|
|
|
|
|
2015-06-02 10:46:44 -07:00
|
|
|
|
return _syncManager.GetSyncedItemProgresses(new SyncJobItemQuery
|
2015-01-24 12:03:55 -07:00
|
|
|
|
{
|
2015-01-24 23:34:50 -07:00
|
|
|
|
TargetId = deviceId,
|
2015-04-03 19:16:42 -07:00
|
|
|
|
Statuses = new[]
|
2015-01-24 23:34:50 -07:00
|
|
|
|
{
|
|
|
|
|
SyncJobItemStatus.Converting,
|
|
|
|
|
SyncJobItemStatus.Queued,
|
2015-02-04 20:01:37 -07:00
|
|
|
|
SyncJobItemStatus.Transferring,
|
2015-06-02 10:46:44 -07:00
|
|
|
|
SyncJobItemStatus.ReadyToTransfer,
|
2015-04-03 19:16:42 -07:00
|
|
|
|
SyncJobItemStatus.Synced
|
|
|
|
|
}
|
2015-06-02 10:46:44 -07:00
|
|
|
|
}).Items;
|
2015-01-24 12:03:55 -07:00
|
|
|
|
}
|
|
|
|
|
|
2015-04-12 11:58:21 -07:00
|
|
|
|
public void FillSyncInfo(IEnumerable<IHasSyncInfo> dtos, DtoOptions options, User user)
|
|
|
|
|
{
|
|
|
|
|
if (options.Fields.Contains(ItemFields.SyncInfo))
|
|
|
|
|
{
|
2015-06-02 10:46:44 -07:00
|
|
|
|
var syncProgress = GetSyncedItemProgress(options);
|
2015-04-12 11:58:21 -07:00
|
|
|
|
|
|
|
|
|
foreach (var dto in dtos)
|
|
|
|
|
{
|
|
|
|
|
var item = _libraryManager.GetItemById(dto.Id);
|
|
|
|
|
|
2015-06-02 10:46:44 -07:00
|
|
|
|
FillSyncInfo(dto, item, syncProgress, options, user);
|
2015-04-12 11:58:21 -07:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-02 10:46:44 -07:00
|
|
|
|
private void FillSyncInfo(IHasSyncInfo dto, BaseItem item, DtoOptions options, User user, SyncedItemProgress[] syncProgress)
|
2015-01-24 12:03:55 -07:00
|
|
|
|
{
|
|
|
|
|
if (options.Fields.Contains(ItemFields.SyncInfo))
|
|
|
|
|
{
|
2015-02-11 13:23:07 -07:00
|
|
|
|
var userCanSync = user != null && user.Policy.EnableSync;
|
|
|
|
|
dto.SupportsSync = userCanSync && _syncManager.SupportsSync(item);
|
2015-01-24 12:03:55 -07:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (dto.SupportsSync ?? false)
|
|
|
|
|
{
|
2015-06-02 10:46:44 -07:00
|
|
|
|
dto.HasSyncJob = syncProgress.Any(i => i.Status != SyncJobItemStatus.Synced && string.Equals(i.ItemId, dto.Id, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
dto.IsSynced = syncProgress.Any(i => i.Status == SyncJobItemStatus.Synced && string.Equals(i.ItemId, dto.Id, StringComparison.OrdinalIgnoreCase));
|
2015-04-12 11:58:21 -07:00
|
|
|
|
|
|
|
|
|
if (dto.IsSynced.Value)
|
|
|
|
|
{
|
|
|
|
|
dto.SyncStatus = SyncJobItemStatus.Synced;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
else if (dto.HasSyncJob.Value)
|
|
|
|
|
{
|
|
|
|
|
dto.SyncStatus = SyncJobItemStatus.Queued;
|
|
|
|
|
}
|
2015-01-24 12:03:55 -07:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-02 10:46:44 -07:00
|
|
|
|
private void FillSyncInfo(IHasSyncInfo dto, BaseItem item, SyncedItemProgress[] syncProgress, DtoOptions options, User user)
|
2015-01-24 12:03:55 -07:00
|
|
|
|
{
|
|
|
|
|
if (options.Fields.Contains(ItemFields.SyncInfo))
|
|
|
|
|
{
|
2015-02-11 13:23:07 -07:00
|
|
|
|
var userCanSync = user != null && user.Policy.EnableSync;
|
|
|
|
|
dto.SupportsSync = userCanSync && _syncManager.SupportsSync(item);
|
2015-01-24 12:03:55 -07:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (dto.SupportsSync ?? false)
|
|
|
|
|
{
|
2015-06-02 10:46:44 -07:00
|
|
|
|
dto.HasSyncJob = syncProgress.Any(i => i.Status != SyncJobItemStatus.Synced && string.Equals(i.ItemId, dto.Id, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
dto.IsSynced = syncProgress.Any(i => i.Status == SyncJobItemStatus.Synced && string.Equals(i.ItemId, dto.Id, StringComparison.OrdinalIgnoreCase));
|
2015-04-12 11:58:21 -07:00
|
|
|
|
|
|
|
|
|
if (dto.IsSynced.Value)
|
|
|
|
|
{
|
|
|
|
|
dto.SyncStatus = SyncJobItemStatus.Synced;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
else if (dto.HasSyncJob.Value)
|
|
|
|
|
{
|
|
|
|
|
dto.SyncStatus = SyncJobItemStatus.Queued;
|
|
|
|
|
}
|
2015-01-24 12:03:55 -07:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-26 22:03:34 -07:00
|
|
|
|
private BaseItemDto GetBaseItemDtoInternal(BaseItem item, DtoOptions options, Dictionary<string, SyncedItemProgress> syncProgress, User user = null, BaseItem owner = null)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2014-11-30 12:01:33 -07:00
|
|
|
|
var fields = options.Fields;
|
|
|
|
|
|
2013-02-20 18:33:05 -07:00
|
|
|
|
if (item == null)
|
|
|
|
|
{
|
|
|
|
|
throw new ArgumentNullException("item");
|
|
|
|
|
}
|
2013-05-15 09:56:38 -07:00
|
|
|
|
|
2013-02-20 18:33:05 -07:00
|
|
|
|
if (fields == null)
|
|
|
|
|
{
|
|
|
|
|
throw new ArgumentNullException("fields");
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-23 21:54:35 -07:00
|
|
|
|
var dto = new BaseItemDto
|
|
|
|
|
{
|
|
|
|
|
ServerId = _appHost.SystemId
|
|
|
|
|
};
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-04-02 19:59:27 -07:00
|
|
|
|
if (fields.Contains(ItemFields.People))
|
|
|
|
|
{
|
2013-09-16 19:08:18 -07:00
|
|
|
|
AttachPeople(dto, item);
|
2013-04-02 19:59:27 -07:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (fields.Contains(ItemFields.PrimaryImageAspectRatio))
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
2016-01-15 22:01:57 -07:00
|
|
|
|
AttachPrimaryImageAspectRatio(dto, item);
|
2013-04-02 19:59:27 -07: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);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-25 10:18:56 -07:00
|
|
|
|
if (fields.Contains(ItemFields.DisplayPreferencesId))
|
|
|
|
|
{
|
|
|
|
|
dto.DisplayPreferencesId = item.DisplayPreferencesId.ToString("N");
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-17 13:35:43 -07:00
|
|
|
|
if (user != null)
|
|
|
|
|
{
|
2015-06-02 10:46:44 -07:00
|
|
|
|
AttachUserSpecificInfo(dto, item, user, fields, syncProgress);
|
2013-06-17 13:35:43 -07:00
|
|
|
|
}
|
|
|
|
|
|
2014-06-14 11:24:20 -07:00
|
|
|
|
var hasMediaSources = item as IHasMediaSources;
|
|
|
|
|
if (hasMediaSources != null)
|
|
|
|
|
{
|
|
|
|
|
if (fields.Contains(ItemFields.MediaSources))
|
|
|
|
|
{
|
|
|
|
|
if (user == null)
|
|
|
|
|
{
|
2015-03-31 09:24:16 -07:00
|
|
|
|
dto.MediaSources = _mediaSourceManager().GetStaticMediaSources(hasMediaSources, true).ToList();
|
2014-06-14 11:24:20 -07:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2015-03-07 15:43:53 -07:00
|
|
|
|
dto.MediaSources = _mediaSourceManager().GetStaticMediaSources(hasMediaSources, true, user).ToList();
|
2014-06-14 11:24:20 -07:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-04-03 19:16:42 -07:00
|
|
|
|
|
2013-09-16 19:08:18 -07:00
|
|
|
|
if (fields.Contains(ItemFields.Studios))
|
|
|
|
|
{
|
|
|
|
|
AttachStudios(dto, item);
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-30 12:01:33 -07:00
|
|
|
|
AttachBasicFields(dto, item, owner, options);
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2015-08-30 21:57:12 -07:00
|
|
|
|
var tvChannel = item as LiveTvChannel;
|
|
|
|
|
if (tvChannel != null)
|
|
|
|
|
{
|
|
|
|
|
_livetvManager().AddChannelInfo(dto, tvChannel, options, user);
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-29 13:31:15 -07:00
|
|
|
|
var collectionFolder = item as ICollectionFolder;
|
|
|
|
|
if (collectionFolder != null)
|
|
|
|
|
{
|
2015-11-18 22:19:54 -07:00
|
|
|
|
dto.OriginalCollectionType = collectionFolder.CollectionType;
|
|
|
|
|
|
2015-07-29 13:31:15 -07:00
|
|
|
|
dto.CollectionType = user == null ?
|
|
|
|
|
collectionFolder.CollectionType :
|
|
|
|
|
collectionFolder.GetViewType(user);
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-30 12:01:33 -07:00
|
|
|
|
var playlist = item as Playlist;
|
|
|
|
|
if (playlist != null)
|
2014-08-02 19:16:37 -07:00
|
|
|
|
{
|
2014-11-30 12:01:33 -07:00
|
|
|
|
AttachLinkedChildImages(dto, playlist, user, options);
|
2014-08-02 19:16:37 -07:00
|
|
|
|
}
|
|
|
|
|
|
2015-02-05 22:39:07 -07:00
|
|
|
|
if (fields.Contains(ItemFields.CanDelete))
|
|
|
|
|
{
|
|
|
|
|
dto.CanDelete = user == null
|
|
|
|
|
? item.CanDelete()
|
|
|
|
|
: item.CanDelete(user);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (fields.Contains(ItemFields.CanDownload))
|
|
|
|
|
{
|
|
|
|
|
dto.CanDownload = user == null
|
|
|
|
|
? item.CanDownload()
|
|
|
|
|
: item.CanDownload(user);
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-15 08:41:42 -07:00
|
|
|
|
if (fields.Contains(ItemFields.Etag))
|
|
|
|
|
{
|
|
|
|
|
dto.Etag = item.GetEtag(user);
|
|
|
|
|
}
|
2015-04-13 20:45:17 -07:00
|
|
|
|
|
2015-05-31 11:22:51 -07:00
|
|
|
|
if (item is ILiveTvRecording)
|
|
|
|
|
{
|
|
|
|
|
_livetvManager().AddInfoToRecordingDto(item, dto, user);
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-31 12:12:58 -07:00
|
|
|
|
else if (item is LiveTvProgram)
|
|
|
|
|
{
|
2015-10-11 09:12:53 -07:00
|
|
|
|
_livetvManager().AddInfoToProgramDto(item, dto, fields.Contains(ItemFields.ChannelInfo), user);
|
2015-05-31 12:12:58 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-02-20 18:33:05 -07:00
|
|
|
|
return dto;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-14 20:15:25 -07:00
|
|
|
|
public BaseItemDto GetItemByNameDto(BaseItem item, DtoOptions options, List<BaseItem> taggedItems, User user = null)
|
2013-09-10 11:56:00 -07:00
|
|
|
|
{
|
2015-06-02 10:46:44 -07:00
|
|
|
|
var syncProgress = GetSyncedItemProgress(options);
|
|
|
|
|
|
2015-07-12 12:33:00 -07:00
|
|
|
|
var dto = GetBaseItemDtoInternal(item, options, GetSyncedItemProgressDictionary(syncProgress), user);
|
2014-06-28 12:35:30 -07:00
|
|
|
|
|
2015-04-03 19:34:53 -07:00
|
|
|
|
if (options.Fields.Contains(ItemFields.ItemCounts))
|
2015-03-25 21:44:24 -07:00
|
|
|
|
{
|
|
|
|
|
SetItemByNameInfo(item, dto, taggedItems, user);
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-02 10:46:44 -07:00
|
|
|
|
FillSyncInfo(dto, item, options, user, syncProgress);
|
2014-03-09 15:14:44 -07:00
|
|
|
|
|
2014-06-28 12:35:30 -07:00
|
|
|
|
return dto;
|
2014-03-09 15:14:44 -07:00
|
|
|
|
}
|
|
|
|
|
|
2014-06-28 12:35:30 -07:00
|
|
|
|
private void SetItemByNameInfo(BaseItem item, BaseItemDto dto, List<BaseItem> taggedItems, User user = null)
|
2014-03-09 15:14:44 -07:00
|
|
|
|
{
|
|
|
|
|
if (item is MusicArtist || item is MusicGenre)
|
2013-09-10 11:56:00 -07:00
|
|
|
|
{
|
2014-03-09 15:14:44 -07:00
|
|
|
|
dto.AlbumCount = taggedItems.Count(i => i is MusicAlbum);
|
|
|
|
|
dto.MusicVideoCount = taggedItems.Count(i => i is MusicVideo);
|
|
|
|
|
dto.SongCount = taggedItems.Count(i => i is Audio);
|
|
|
|
|
}
|
|
|
|
|
else if (item is GameGenre)
|
|
|
|
|
{
|
|
|
|
|
dto.GameCount = taggedItems.Count(i => i is Game);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
// This populates them all and covers Genre, Person, Studio, Year
|
|
|
|
|
|
|
|
|
|
dto.AlbumCount = taggedItems.Count(i => i is MusicAlbum);
|
|
|
|
|
dto.EpisodeCount = taggedItems.Count(i => i is Episode);
|
|
|
|
|
dto.GameCount = taggedItems.Count(i => i is Game);
|
|
|
|
|
dto.MovieCount = taggedItems.Count(i => i is Movie);
|
|
|
|
|
dto.MusicVideoCount = taggedItems.Count(i => i is MusicVideo);
|
|
|
|
|
dto.SeriesCount = taggedItems.Count(i => i is Series);
|
|
|
|
|
dto.SongCount = taggedItems.Count(i => i is Audio);
|
2013-09-10 11:56:00 -07:00
|
|
|
|
}
|
2013-12-02 14:46:22 -07:00
|
|
|
|
|
2014-03-09 15:14:44 -07:00
|
|
|
|
dto.ChildCount = taggedItems.Count;
|
2013-09-10 11:56:00 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-02-20 18:33:05 -07: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>
|
2015-06-02 10:46:44 -07:00
|
|
|
|
/// <param name="syncProgress">The synchronize progress.</param>
|
|
|
|
|
private void AttachUserSpecificInfo(BaseItemDto dto, BaseItem item, User user, List<ItemFields> fields, Dictionary<string, SyncedItemProgress> syncProgress)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
|
|
|
|
if (item.IsFolder)
|
|
|
|
|
{
|
2014-07-03 19:22:57 -07:00
|
|
|
|
var userData = _userDataRepository.GetUserData(user.Id, item.GetUserDataKey());
|
|
|
|
|
|
|
|
|
|
// Skip the user data manager because we've already looped through the recursive tree and don't want to do it twice
|
|
|
|
|
// TODO: Improve in future
|
|
|
|
|
dto.UserData = GetUserItemDataDto(userData);
|
|
|
|
|
|
2013-09-23 07:26:20 -07:00
|
|
|
|
var folder = (Folder)item;
|
2013-07-25 12:17:44 -07:00
|
|
|
|
|
2015-11-02 10:25:01 -07:00
|
|
|
|
if (!(folder is IChannelItem) && !(folder is Channel))
|
2013-09-23 07:26:20 -07:00
|
|
|
|
{
|
2015-11-02 10:25:01 -07:00
|
|
|
|
dto.ChildCount = GetChildCount(folder, user);
|
|
|
|
|
|
|
|
|
|
// These are just far too slow.
|
|
|
|
|
if (!(folder is UserRootFolder) && !(folder is UserView) && !(folder is ICollectionFolder))
|
|
|
|
|
{
|
|
|
|
|
SetSpecialCounts(folder, user, dto, fields, syncProgress);
|
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
2013-05-07 18:17:41 -07:00
|
|
|
|
|
2014-08-16 22:38:13 -07:00
|
|
|
|
dto.UserData.Played = dto.UserData.PlayedPercentage.HasValue && dto.UserData.PlayedPercentage.Value >= 100;
|
2014-07-03 19:22:57 -07:00
|
|
|
|
}
|
2013-05-07 18:17:41 -07:00
|
|
|
|
|
2014-07-03 19:22:57 -07:00
|
|
|
|
else
|
2013-07-16 10:18:32 -07:00
|
|
|
|
{
|
2014-07-03 19:22:57 -07:00
|
|
|
|
dto.UserData = _userDataRepository.GetUserDataDto(item, user);
|
2013-05-07 18:17:41 -07:00
|
|
|
|
}
|
2014-02-20 22:35:56 -07:00
|
|
|
|
|
|
|
|
|
dto.PlayAccess = item.GetPlayAccess(user);
|
2014-12-26 22:08:39 -07:00
|
|
|
|
|
|
|
|
|
if (fields.Contains(ItemFields.SeasonUserData))
|
|
|
|
|
{
|
|
|
|
|
var episode = item as Episode;
|
|
|
|
|
|
|
|
|
|
if (episode != null)
|
|
|
|
|
{
|
|
|
|
|
var season = episode.Season;
|
|
|
|
|
|
|
|
|
|
if (season != null)
|
|
|
|
|
{
|
|
|
|
|
dto.SeasonUserData = _userDataRepository.GetUserDataDto(season, user);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-03-05 23:10:53 -07:00
|
|
|
|
|
|
|
|
|
var userView = item as UserView;
|
|
|
|
|
if (userView != null)
|
|
|
|
|
{
|
|
|
|
|
dto.HasDynamicCategories = userView.ContainsDynamicCategories(user);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var collectionFolder = item as ICollectionFolder;
|
|
|
|
|
if (collectionFolder != null)
|
|
|
|
|
{
|
|
|
|
|
dto.HasDynamicCategories = false;
|
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
2013-04-13 11:02:30 -07:00
|
|
|
|
|
2013-12-10 13:42:42 -07:00
|
|
|
|
private int GetChildCount(Folder folder, User user)
|
|
|
|
|
{
|
|
|
|
|
return folder.GetChildren(user, true)
|
|
|
|
|
.Count();
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07: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-04-12 07:13:47 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
throw new ArgumentNullException("item");
|
2013-04-12 07:13:47 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
return item.Id.ToString("N");
|
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07: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-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
throw new ArgumentNullException("data");
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
return new UserItemDataDto
|
2013-06-11 20:00:23 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
IsFavorite = data.IsFavorite,
|
|
|
|
|
Likes = data.Likes,
|
|
|
|
|
PlaybackPositionTicks = data.PlaybackPositionTicks,
|
|
|
|
|
PlayCount = data.PlayCount,
|
|
|
|
|
Rating = data.Rating,
|
|
|
|
|
Played = data.Played,
|
2013-10-03 11:02:23 -07:00
|
|
|
|
LastPlayedDate = data.LastPlayedDate,
|
|
|
|
|
Key = data.Key
|
2013-09-04 10:02:19 -07:00
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
private void SetBookProperties(BaseItemDto dto, Book item)
|
|
|
|
|
{
|
|
|
|
|
dto.SeriesName = item.SeriesName;
|
|
|
|
|
}
|
2014-08-28 17:49:25 -07:00
|
|
|
|
private void SetPhotoProperties(BaseItemDto dto, Photo item)
|
|
|
|
|
{
|
|
|
|
|
dto.Width = item.Width;
|
|
|
|
|
dto.Height = item.Height;
|
|
|
|
|
dto.CameraMake = item.CameraMake;
|
|
|
|
|
dto.CameraModel = item.CameraModel;
|
|
|
|
|
dto.Software = item.Software;
|
|
|
|
|
dto.ExposureTime = item.ExposureTime;
|
|
|
|
|
dto.FocalLength = item.FocalLength;
|
|
|
|
|
dto.ImageOrientation = item.Orientation;
|
|
|
|
|
dto.Aperture = item.Aperture;
|
|
|
|
|
dto.ShutterSpeed = item.ShutterSpeed;
|
2014-08-30 07:26:29 -07:00
|
|
|
|
|
|
|
|
|
dto.Latitude = item.Latitude;
|
|
|
|
|
dto.Longitude = item.Longitude;
|
|
|
|
|
dto.Altitude = item.Altitude;
|
|
|
|
|
dto.IsoSpeedRating = item.IsoSpeedRating;
|
2014-10-12 08:18:26 -07:00
|
|
|
|
|
2014-08-30 07:26:29 -07:00
|
|
|
|
var album = item.Album;
|
|
|
|
|
|
|
|
|
|
if (album != null)
|
|
|
|
|
{
|
2014-09-02 19:30:24 -07:00
|
|
|
|
dto.Album = album.Name;
|
|
|
|
|
dto.AlbumId = album.Id.ToString("N");
|
2014-08-30 07:26:29 -07:00
|
|
|
|
}
|
2014-08-28 17:49:25 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
private void SetMusicVideoProperties(BaseItemDto dto, MusicVideo item)
|
|
|
|
|
{
|
|
|
|
|
if (!string.IsNullOrEmpty(item.Album))
|
|
|
|
|
{
|
|
|
|
|
var parentAlbum = _libraryManager.RootFolder
|
2015-01-24 23:34:50 -07:00
|
|
|
|
.GetRecursiveChildren(i => i is MusicAlbum && string.Equals(i.Name, item.Album, StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
.FirstOrDefault();
|
2013-07-05 17:19:44 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (parentAlbum != null)
|
2013-07-05 17:19:44 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.AlbumId = GetDtoId(parentAlbum);
|
2013-07-05 17:19:44 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.Album = item.Album;
|
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
private void SetGameProperties(BaseItemDto dto, Game item)
|
|
|
|
|
{
|
|
|
|
|
dto.Players = item.PlayersSupported;
|
|
|
|
|
dto.GameSystem = item.GameSystem;
|
2014-04-26 20:42:05 -07:00
|
|
|
|
dto.MultiPartGameFiles = item.MultiPartGameFiles;
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-10-27 14:40:42 -07:00
|
|
|
|
private void SetGameSystemProperties(BaseItemDto dto, GameSystem item)
|
|
|
|
|
{
|
|
|
|
|
dto.GameSystem = item.GameSystemName;
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-30 12:01:33 -07:00
|
|
|
|
private List<string> GetBackdropImageTags(BaseItem item, int limit)
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
2014-11-30 12:01:33 -07:00
|
|
|
|
return GetCacheTags(item, ImageType.Backdrop, limit).ToList();
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2014-11-30 12:01:33 -07:00
|
|
|
|
private List<string> GetScreenshotImageTags(BaseItem item, int limit)
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
2013-12-05 09:50:21 -07:00
|
|
|
|
var hasScreenshots = item as IHasScreenshots;
|
|
|
|
|
if (hasScreenshots == null)
|
|
|
|
|
{
|
2014-05-08 13:09:53 -07:00
|
|
|
|
return new List<string>();
|
2013-12-05 09:50:21 -07:00
|
|
|
|
}
|
2014-11-30 12:01:33 -07:00
|
|
|
|
return GetCacheTags(item, ImageType.Screenshot, limit).ToList();
|
2014-02-07 13:30:41 -07:00
|
|
|
|
}
|
2013-12-05 09:50:21 -07:00
|
|
|
|
|
2014-11-30 12:01:33 -07:00
|
|
|
|
private IEnumerable<string> GetCacheTags(BaseItem item, ImageType type, int limit)
|
2014-02-07 13:30:41 -07:00
|
|
|
|
{
|
|
|
|
|
return item.GetImages(type)
|
|
|
|
|
.Select(p => GetImageCacheTag(item, p))
|
2014-05-08 13:09:53 -07:00
|
|
|
|
.Where(i => i != null)
|
2014-11-30 12:01:33 -07:00
|
|
|
|
.Take(limit)
|
2013-09-04 10:02:19 -07:00
|
|
|
|
.ToList();
|
|
|
|
|
}
|
2013-03-12 19:10:43 -07:00
|
|
|
|
|
2014-05-08 13:09:53 -07:00
|
|
|
|
private string GetImageCacheTag(BaseItem item, ImageType type)
|
2014-02-07 13:30:41 -07:00
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
return _imageProcessor.GetImageCacheTag(item, type);
|
|
|
|
|
}
|
2014-04-13 10:27:13 -07:00
|
|
|
|
catch (Exception ex)
|
2014-02-07 13:30:41 -07:00
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting {0} image info", ex, type);
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-08 13:09:53 -07:00
|
|
|
|
private string GetImageCacheTag(BaseItem item, ItemImageInfo image)
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
|
|
|
|
try
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2014-02-07 13:30:41 -07:00
|
|
|
|
return _imageProcessor.GetImageCacheTag(item, image);
|
2013-03-12 15:49:45 -07:00
|
|
|
|
}
|
2014-04-13 10:27:13 -07:00
|
|
|
|
catch (Exception ex)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2014-02-07 13:30:41 -07:00
|
|
|
|
_logger.ErrorException("Error getting {0} image info for {1}", ex, image.Type, image.Path);
|
2013-09-04 10:02:19 -07:00
|
|
|
|
return null;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
2013-09-16 19:08:18 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-10 11:56:00 -07:00
|
|
|
|
/// <summary>
|
2013-09-04 10:02:19 -07:00
|
|
|
|
/// Attaches People DTO's to a DTOBaseItem
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="dto">The dto.</param>
|
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
|
/// <returns>Task.</returns>
|
2013-09-16 19:08:18 -07:00
|
|
|
|
private void AttachPeople(BaseItemDto dto, BaseItem item)
|
2013-09-04 10:02:19 -07: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
|
2015-06-20 20:35:22 -07:00
|
|
|
|
var people = _libraryManager.GetPeople(item).OrderBy(i => i.SortOrder ?? int.MaxValue)
|
2014-06-30 06:28:38 -07:00
|
|
|
|
.ThenBy(i =>
|
|
|
|
|
{
|
|
|
|
|
if (i.IsType(PersonType.Actor))
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (i.IsType(PersonType.GuestStar))
|
|
|
|
|
{
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
if (i.IsType(PersonType.Director))
|
|
|
|
|
{
|
|
|
|
|
return 2;
|
|
|
|
|
}
|
|
|
|
|
if (i.IsType(PersonType.Writer))
|
|
|
|
|
{
|
|
|
|
|
return 3;
|
|
|
|
|
}
|
|
|
|
|
if (i.IsType(PersonType.Producer))
|
|
|
|
|
{
|
|
|
|
|
return 4;
|
|
|
|
|
}
|
|
|
|
|
if (i.IsType(PersonType.Composer))
|
|
|
|
|
{
|
|
|
|
|
return 4;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 10;
|
|
|
|
|
})
|
|
|
|
|
.ToList();
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2014-11-21 07:28:30 -07:00
|
|
|
|
var list = new List<BaseItemPerson>();
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-16 19:08:18 -07:00
|
|
|
|
var dictionary = people.Select(p => p.Name)
|
2013-09-04 10:02:19 -07:00
|
|
|
|
.Distinct(StringComparer.OrdinalIgnoreCase).Select(c =>
|
2013-09-16 19:08:18 -07:00
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
return _libraryManager.GetPerson(c);
|
|
|
|
|
}
|
2014-08-24 20:54:45 -07:00
|
|
|
|
catch (Exception ex)
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
2013-09-16 19:08:18 -07:00
|
|
|
|
_logger.ErrorException("Error getting person {0}", ex, c);
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}).Where(i => i != null)
|
2015-07-01 08:47:41 -07:00
|
|
|
|
.DistinctBy(i => i.Name, StringComparer.OrdinalIgnoreCase)
|
2013-09-04 10:02:19 -07:00
|
|
|
|
.ToDictionary(i => i.Name, StringComparer.OrdinalIgnoreCase);
|
|
|
|
|
|
|
|
|
|
for (var i = 0; i < people.Count; i++)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
var person = people[i];
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
var baseItemPerson = new BaseItemPerson
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
Name = person.Name,
|
|
|
|
|
Role = person.Role,
|
|
|
|
|
Type = person.Type
|
|
|
|
|
};
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
Person entity;
|
|
|
|
|
|
|
|
|
|
if (dictionary.TryGetValue(person.Name, out entity))
|
|
|
|
|
{
|
2014-02-07 13:30:41 -07:00
|
|
|
|
baseItemPerson.PrimaryImageTag = GetImageCacheTag(entity, ImageType.Primary);
|
2014-05-11 15:38:10 -07:00
|
|
|
|
baseItemPerson.Id = entity.Id.ToString("N");
|
2014-11-21 07:28:30 -07:00
|
|
|
|
list.Add(baseItemPerson);
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
}
|
2014-11-21 07:28:30 -07:00
|
|
|
|
|
|
|
|
|
dto.People = list.ToArray();
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Attaches the studios.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="dto">The dto.</param>
|
|
|
|
|
/// <param name="item">The item.</param>
|
|
|
|
|
/// <returns>Task.</returns>
|
2013-09-16 19:08:18 -07:00
|
|
|
|
private void AttachStudios(BaseItemDto dto, BaseItem item)
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
|
|
|
|
var studios = item.Studios.ToList();
|
|
|
|
|
|
|
|
|
|
dto.Studios = new StudioDto[studios.Count];
|
|
|
|
|
|
2013-09-16 19:08:18 -07:00
|
|
|
|
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)
|
2015-07-01 22:08:05 -07:00
|
|
|
|
.DistinctBy(i => i.Name, StringComparer.OrdinalIgnoreCase)
|
2013-09-16 19:08:18 -07:00
|
|
|
|
.ToDictionary(i => i.Name, StringComparer.OrdinalIgnoreCase);
|
2013-09-04 10:02:19 -07:00
|
|
|
|
|
|
|
|
|
for (var i = 0; i < studios.Count; i++)
|
2013-07-08 12:31:45 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
var studio = studios[i];
|
2013-07-08 12:31:45 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
var studioDto = new StudioDto
|
2013-07-08 12:31:45 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
Name = studio
|
|
|
|
|
};
|
2013-07-08 12:31:45 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
Studio entity;
|
|
|
|
|
|
|
|
|
|
if (dictionary.TryGetValue(studio, out entity))
|
|
|
|
|
{
|
2014-07-01 14:13:32 -07:00
|
|
|
|
studioDto.Id = entity.Id.ToString("N");
|
2014-02-07 13:30:41 -07:00
|
|
|
|
studioDto.PrimaryImageTag = GetImageCacheTag(entity, ImageType.Primary);
|
2013-07-08 12:31:45 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.Studios[i] = studioDto;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07: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)
|
|
|
|
|
{
|
2015-11-11 07:56:31 -07:00
|
|
|
|
var parent = item.GetParent() ?? owner;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
while (parent != null)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2014-02-07 13:30:41 -07:00
|
|
|
|
if (parent.GetImages(ImageType.Backdrop).Any())
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
|
|
|
|
return parent;
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-11 07:56:31 -07:00
|
|
|
|
parent = parent.GetParent();
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
return null;
|
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07: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)
|
|
|
|
|
{
|
2015-11-11 07:56:31 -07:00
|
|
|
|
var parent = item.GetParent() ?? owner;
|
2013-09-04 10:02:19 -07:00
|
|
|
|
|
|
|
|
|
while (parent != null)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (parent.HasImage(type))
|
|
|
|
|
{
|
|
|
|
|
return parent;
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-11 07:56:31 -07:00
|
|
|
|
parent = parent.GetParent();
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07: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>
|
2014-10-12 08:18:26 -07:00
|
|
|
|
private ChapterInfoDto GetChapterInfoDto(ChapterInfo chapterInfo, BaseItem item)
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
|
|
|
|
var dto = new ChapterInfoDto
|
2013-06-24 18:22:21 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
Name = chapterInfo.Name,
|
|
|
|
|
StartPositionTicks = chapterInfo.StartPositionTicks
|
|
|
|
|
};
|
2013-07-05 17:19:44 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (!string.IsNullOrEmpty(chapterInfo.ImagePath))
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2014-02-07 13:30:41 -07:00
|
|
|
|
dto.ImageTag = GetImageCacheTag(item, new ItemImageInfo
|
|
|
|
|
{
|
|
|
|
|
Path = chapterInfo.ImagePath,
|
|
|
|
|
Type = ImageType.Chapter,
|
2015-04-19 12:17:17 -07:00
|
|
|
|
DateModified = _fileSystem.GetLastWriteTimeUtc(chapterInfo.ImagePath)
|
2014-02-07 13:30:41 -07:00
|
|
|
|
});
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
return dto;
|
|
|
|
|
}
|
|
|
|
|
|
2014-10-12 08:18:26 -07:00
|
|
|
|
public List<ChapterInfoDto> GetChapterInfoDtos(BaseItem item)
|
|
|
|
|
{
|
|
|
|
|
return _itemRepo.GetChapters(item.Id)
|
|
|
|
|
.Select(c => GetChapterInfoDto(c, item))
|
|
|
|
|
.ToList();
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07: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>
|
2014-11-30 12:01:33 -07:00
|
|
|
|
/// <param name="options">The options.</param>
|
|
|
|
|
private void AttachBasicFields(BaseItemDto dto, BaseItem item, BaseItem owner, DtoOptions options)
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
2014-11-30 12:01:33 -07:00
|
|
|
|
var fields = options.Fields;
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (fields.Contains(ItemFields.DateCreated))
|
2013-05-23 21:02:42 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.DateCreated = item.DateCreated;
|
2013-05-23 21:02:42 -07:00
|
|
|
|
}
|
|
|
|
|
|
2014-03-21 09:55:47 -07:00
|
|
|
|
if (fields.Contains(ItemFields.DisplayMediaType))
|
|
|
|
|
{
|
|
|
|
|
dto.DisplayMediaType = item.DisplayMediaType;
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-20 22:57:06 -07:00
|
|
|
|
if (fields.Contains(ItemFields.Settings))
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
|
|
|
|
dto.LockedFields = item.LockedFields;
|
2014-03-22 09:16:43 -07:00
|
|
|
|
dto.LockData = item.IsLocked;
|
2014-03-24 10:54:45 -07:00
|
|
|
|
dto.ForcedSortName = item.ForcedSortName;
|
2013-07-16 09:03:28 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-12-02 09:16:03 -07:00
|
|
|
|
var hasBudget = item as IHasBudget;
|
|
|
|
|
if (hasBudget != null)
|
2013-07-16 09:03:28 -07:00
|
|
|
|
{
|
2013-12-02 09:16:03 -07:00
|
|
|
|
if (fields.Contains(ItemFields.Budget))
|
|
|
|
|
{
|
|
|
|
|
dto.Budget = hasBudget.Budget;
|
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-12-02 09:16:03 -07:00
|
|
|
|
if (fields.Contains(ItemFields.Revenue))
|
|
|
|
|
{
|
|
|
|
|
dto.Revenue = hasBudget.Revenue;
|
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
2013-04-24 15:34:38 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.EndDate = item.EndDate;
|
2013-04-24 15:34:38 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (fields.Contains(ItemFields.HomePageUrl))
|
2013-04-24 15:34:38 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.HomePageUrl = item.HomePageUrl;
|
2013-04-24 15:34:38 -07:00
|
|
|
|
}
|
2013-07-12 12:56:40 -07:00
|
|
|
|
|
2014-02-21 11:48:15 -07:00
|
|
|
|
if (fields.Contains(ItemFields.ExternalUrls))
|
|
|
|
|
{
|
|
|
|
|
dto.ExternalUrls = _providerManager.GetExternalUrls(item).ToArray();
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (fields.Contains(ItemFields.Tags))
|
|
|
|
|
{
|
2013-12-05 09:50:21 -07:00
|
|
|
|
var hasTags = item as IHasTags;
|
|
|
|
|
if (hasTags != null)
|
|
|
|
|
{
|
|
|
|
|
dto.Tags = hasTags.Tags;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (dto.Tags == null)
|
|
|
|
|
{
|
|
|
|
|
dto.Tags = new List<string>();
|
|
|
|
|
}
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
2013-07-12 12:56:40 -07:00
|
|
|
|
|
2014-01-14 08:50:39 -07:00
|
|
|
|
if (fields.Contains(ItemFields.Keywords))
|
|
|
|
|
{
|
2014-02-07 13:30:41 -07:00
|
|
|
|
var hasTags = item as IHasKeywords;
|
2014-01-14 08:50:39 -07:00
|
|
|
|
if (hasTags != null)
|
|
|
|
|
{
|
|
|
|
|
dto.Keywords = hasTags.Keywords;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (dto.Keywords == null)
|
|
|
|
|
{
|
|
|
|
|
dto.Keywords = new List<string>();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (fields.Contains(ItemFields.ProductionLocations))
|
2013-07-12 12:56:40 -07:00
|
|
|
|
{
|
2013-12-05 09:50:21 -07:00
|
|
|
|
SetProductionLocations(item, dto);
|
2013-07-12 12:56:40 -07:00
|
|
|
|
}
|
2013-08-30 16:55:17 -07:00
|
|
|
|
|
2013-11-19 20:15:48 -07:00
|
|
|
|
var hasAspectRatio = item as IHasAspectRatio;
|
|
|
|
|
if (hasAspectRatio != null)
|
|
|
|
|
{
|
|
|
|
|
dto.AspectRatio = hasAspectRatio.AspectRatio;
|
|
|
|
|
}
|
2013-08-30 16:55:17 -07:00
|
|
|
|
|
2014-12-20 11:56:32 -07:00
|
|
|
|
if (fields.Contains(ItemFields.Metascore))
|
2014-01-14 22:01:58 -07:00
|
|
|
|
{
|
2014-11-30 12:01:33 -07:00
|
|
|
|
var hasMetascore = item as IHasMetascore;
|
|
|
|
|
if (hasMetascore != null)
|
|
|
|
|
{
|
|
|
|
|
dto.Metascore = hasMetascore.Metascore;
|
|
|
|
|
}
|
2014-01-14 22:01:58 -07:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (fields.Contains(ItemFields.AwardSummary))
|
|
|
|
|
{
|
|
|
|
|
var hasAwards = item as IHasAwards;
|
|
|
|
|
if (hasAwards != null)
|
|
|
|
|
{
|
|
|
|
|
dto.AwardSummary = hasAwards.AwardSummary;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-30 12:01:33 -07:00
|
|
|
|
var backdropLimit = options.GetImageLimit(ImageType.Backdrop);
|
|
|
|
|
if (backdropLimit > 0)
|
|
|
|
|
{
|
|
|
|
|
dto.BackdropImageTags = GetBackdropImageTags(item, backdropLimit);
|
|
|
|
|
}
|
2013-09-17 19:43:34 -07:00
|
|
|
|
|
|
|
|
|
if (fields.Contains(ItemFields.ScreenshotImageTags))
|
|
|
|
|
{
|
2014-11-30 12:01:33 -07:00
|
|
|
|
var screenshotLimit = options.GetImageLimit(ImageType.Screenshot);
|
|
|
|
|
if (screenshotLimit > 0)
|
|
|
|
|
{
|
|
|
|
|
dto.ScreenshotImageTags = GetScreenshotImageTags(item, screenshotLimit);
|
|
|
|
|
}
|
2013-09-17 19:43:34 -07:00
|
|
|
|
}
|
2013-09-04 10:02:19 -07:00
|
|
|
|
|
|
|
|
|
if (fields.Contains(ItemFields.Genres))
|
2013-08-30 16:55:17 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.Genres = item.Genres;
|
2013-08-30 16:55:17 -07:00
|
|
|
|
}
|
2013-07-12 12:56:40 -07:00
|
|
|
|
|
2014-05-08 13:09:53 -07:00
|
|
|
|
dto.ImageTags = new Dictionary<ImageType, string>();
|
2013-08-30 18:08:32 -07:00
|
|
|
|
|
2014-02-07 13:30:41 -07:00
|
|
|
|
// Prevent implicitly captured closure
|
|
|
|
|
var currentItem = item;
|
2015-02-21 00:32:49 -07:00
|
|
|
|
foreach (var image in currentItem.ImageInfos.Where(i => !currentItem.AllowsMultipleImages(i.Type))
|
|
|
|
|
.ToList())
|
2013-07-22 17:03:33 -07:00
|
|
|
|
{
|
2014-11-30 12:01:33 -07:00
|
|
|
|
if (options.GetImageLimit(image.Type) > 0)
|
2013-07-22 17:03:33 -07:00
|
|
|
|
{
|
2014-11-30 12:01:33 -07:00
|
|
|
|
var tag = GetImageCacheTag(item, image);
|
|
|
|
|
|
|
|
|
|
if (tag != null)
|
|
|
|
|
{
|
|
|
|
|
dto.ImageTags[image.Type] = tag;
|
|
|
|
|
}
|
2013-07-22 17:03:33 -07:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.Id = GetDtoId(item);
|
|
|
|
|
dto.IndexNumber = item.IndexNumber;
|
|
|
|
|
dto.IsFolder = item.IsFolder;
|
|
|
|
|
dto.MediaType = item.MediaType;
|
|
|
|
|
dto.LocationType = item.LocationType;
|
2015-10-28 12:40:38 -07:00
|
|
|
|
if (item.IsHD.HasValue && item.IsHD.Value)
|
|
|
|
|
{
|
|
|
|
|
dto.IsHD = item.IsHD;
|
|
|
|
|
}
|
|
|
|
|
dto.Audio = item.Audio;
|
2013-09-11 10:54:59 -07:00
|
|
|
|
|
2015-09-29 10:35:23 -07:00
|
|
|
|
dto.PreferredMetadataCountryCode = item.PreferredMetadataCountryCode;
|
|
|
|
|
dto.PreferredMetadataLanguage = item.PreferredMetadataLanguage;
|
2013-12-05 09:50:21 -07:00
|
|
|
|
|
2013-11-06 09:06:16 -07:00
|
|
|
|
var hasCriticRating = item as IHasCriticRating;
|
|
|
|
|
if (hasCriticRating != null)
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
2013-11-06 09:06:16 -07:00
|
|
|
|
dto.CriticRating = hasCriticRating.CriticRating;
|
|
|
|
|
|
|
|
|
|
if (fields.Contains(ItemFields.CriticRatingSummary))
|
|
|
|
|
{
|
|
|
|
|
dto.CriticRatingSummary = hasCriticRating.CriticRatingSummary;
|
|
|
|
|
}
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-12-02 09:46:25 -07:00
|
|
|
|
var hasTrailers = item as IHasTrailers;
|
|
|
|
|
if (hasTrailers != null)
|
|
|
|
|
{
|
2014-12-10 23:20:28 -07:00
|
|
|
|
dto.LocalTrailerCount = hasTrailers.GetTrailerIds().Count;
|
2013-12-02 09:46:25 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2014-01-03 13:32:27 -07:00
|
|
|
|
var hasDisplayOrder = item as IHasDisplayOrder;
|
|
|
|
|
if (hasDisplayOrder != null)
|
|
|
|
|
{
|
|
|
|
|
dto.DisplayOrder = hasDisplayOrder.DisplayOrder;
|
|
|
|
|
}
|
2014-01-03 19:35:41 -07:00
|
|
|
|
|
2014-06-04 19:32:40 -07:00
|
|
|
|
var userView = item as UserView;
|
|
|
|
|
if (userView != null)
|
|
|
|
|
{
|
|
|
|
|
dto.CollectionType = userView.ViewType;
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-02 09:46:25 -07:00
|
|
|
|
if (fields.Contains(ItemFields.RemoteTrailers))
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-12-02 09:46:25 -07:00
|
|
|
|
dto.RemoteTrailers = hasTrailers != null ?
|
|
|
|
|
hasTrailers.RemoteTrailers :
|
|
|
|
|
new List<MediaUrl>();
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.Name = item.Name;
|
|
|
|
|
dto.OfficialRating = item.OfficialRating;
|
2013-03-08 22:15:51 -07:00
|
|
|
|
|
2014-05-27 07:30:21 -07:00
|
|
|
|
if (fields.Contains(ItemFields.Overview))
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
2014-08-05 16:59:24 -07:00
|
|
|
|
dto.Overview = item.Overview;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
2014-06-23 21:18:02 -07:00
|
|
|
|
if (fields.Contains(ItemFields.ShortOverview))
|
|
|
|
|
{
|
|
|
|
|
var hasShortOverview = item as IHasShortOverview;
|
|
|
|
|
if (hasShortOverview != null)
|
|
|
|
|
{
|
|
|
|
|
dto.ShortOverview = hasShortOverview.ShortOverview;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
// If there are no backdrops, indicate what parent has them in case the Ui wants to allow inheritance
|
2014-11-30 12:01:33 -07:00
|
|
|
|
if (backdropLimit > 0 && dto.BackdropImageTags.Count == 0)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
var parentWithBackdrop = GetParentBackdropItem(item, owner);
|
|
|
|
|
|
|
|
|
|
if (parentWithBackdrop != null)
|
|
|
|
|
{
|
|
|
|
|
dto.ParentBackdropItemId = GetDtoId(parentWithBackdrop);
|
2014-11-30 12:01:33 -07:00
|
|
|
|
dto.ParentBackdropImageTags = GetBackdropImageTags(parentWithBackdrop, backdropLimit);
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
2013-07-25 12:17:44 -07:00
|
|
|
|
|
2014-10-23 21:54:35 -07:00
|
|
|
|
if (fields.Contains(ItemFields.ParentId))
|
2013-07-25 12:17:44 -07:00
|
|
|
|
{
|
2014-10-23 21:54:35 -07:00
|
|
|
|
var displayParent = item.DisplayParent;
|
|
|
|
|
if (displayParent != null)
|
|
|
|
|
{
|
|
|
|
|
dto.ParentId = GetDtoId(displayParent);
|
|
|
|
|
}
|
2013-07-25 12:17:44 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.ParentIndexNumber = item.ParentIndexNumber;
|
2013-04-14 13:47:09 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
// If there is no logo, indicate what parent has one in case the Ui wants to allow inheritance
|
2014-11-30 12:01:33 -07:00
|
|
|
|
if (!dto.HasLogo && options.GetImageLimit(ImageType.Logo) > 0)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
var parentWithLogo = GetParentImageItem(item, ImageType.Logo, owner);
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (parentWithLogo != null)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.ParentLogoItemId = GetDtoId(parentWithLogo);
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2014-02-07 13:30:41 -07:00
|
|
|
|
dto.ParentLogoImageTag = GetImageCacheTag(parentWithLogo, ImageType.Logo);
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
// If there is no art, indicate what parent has one in case the Ui wants to allow inheritance
|
2014-12-13 22:23:04 -07:00
|
|
|
|
if (!dto.HasArtImage && options.GetImageLimit(ImageType.Art) > 0)
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
|
|
|
|
var parentWithImage = GetParentImageItem(item, ImageType.Art, owner);
|
|
|
|
|
|
|
|
|
|
if (parentWithImage != null)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.ParentArtItemId = GetDtoId(parentWithImage);
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2014-02-07 13:30:41 -07:00
|
|
|
|
dto.ParentArtImageTag = GetImageCacheTag(parentWithImage, ImageType.Art);
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-10-24 10:49:24 -07:00
|
|
|
|
// If there is no thumb, indicate what parent has one in case the Ui wants to allow inheritance
|
2014-11-30 12:01:33 -07:00
|
|
|
|
if (!dto.HasThumb && options.GetImageLimit(ImageType.Thumb) > 0)
|
2013-10-24 10:49:24 -07:00
|
|
|
|
{
|
|
|
|
|
var parentWithImage = GetParentImageItem(item, ImageType.Thumb, owner);
|
|
|
|
|
|
|
|
|
|
if (parentWithImage != null)
|
|
|
|
|
{
|
|
|
|
|
dto.ParentThumbItemId = GetDtoId(parentWithImage);
|
|
|
|
|
|
2014-02-07 13:30:41 -07:00
|
|
|
|
dto.ParentThumbImageTag = GetImageCacheTag(parentWithImage, ImageType.Thumb);
|
2013-10-24 10:49:24 -07:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (fields.Contains(ItemFields.Path))
|
|
|
|
|
{
|
2014-06-02 12:32:41 -07:00
|
|
|
|
dto.Path = GetMappedPath(item);
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.PremiereDate = item.PremiereDate;
|
|
|
|
|
dto.ProductionYear = item.ProductionYear;
|
2013-05-03 20:13:28 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (fields.Contains(ItemFields.ProviderIds))
|
|
|
|
|
{
|
|
|
|
|
dto.ProviderIds = item.ProviderIds;
|
|
|
|
|
}
|
2013-05-03 20:13:28 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.RunTimeTicks = item.RunTimeTicks;
|
2013-05-03 20:13:28 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (fields.Contains(ItemFields.SortName))
|
|
|
|
|
{
|
|
|
|
|
dto.SortName = item.SortName;
|
|
|
|
|
}
|
2013-05-03 20:13:28 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (fields.Contains(ItemFields.CustomRating))
|
|
|
|
|
{
|
|
|
|
|
dto.CustomRating = item.CustomRating;
|
|
|
|
|
}
|
2013-05-03 20:13:28 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (fields.Contains(ItemFields.Taglines))
|
|
|
|
|
{
|
2013-12-05 09:50:21 -07:00
|
|
|
|
var hasTagline = item as IHasTaglines;
|
|
|
|
|
if (hasTagline != null)
|
|
|
|
|
{
|
|
|
|
|
dto.Taglines = hasTagline.Taglines;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (dto.Taglines == null)
|
|
|
|
|
{
|
|
|
|
|
dto.Taglines = new List<string>();
|
|
|
|
|
}
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
2013-05-03 20:13:28 -07:00
|
|
|
|
|
2013-11-21 13:48:26 -07:00
|
|
|
|
dto.Type = item.GetClientTypeName();
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.CommunityRating = item.CommunityRating;
|
2014-11-30 12:01:33 -07:00
|
|
|
|
|
|
|
|
|
if (fields.Contains(ItemFields.VoteCount))
|
|
|
|
|
{
|
|
|
|
|
dto.VoteCount = item.VoteCount;
|
|
|
|
|
}
|
2013-05-03 20:13:28 -07:00
|
|
|
|
|
2015-11-11 07:56:31 -07:00
|
|
|
|
//if (item.IsFolder)
|
|
|
|
|
//{
|
|
|
|
|
// var folder = (Folder)item;
|
2013-05-03 20:13:28 -07:00
|
|
|
|
|
2015-11-11 07:56:31 -07:00
|
|
|
|
// if (fields.Contains(ItemFields.IndexOptions))
|
|
|
|
|
// {
|
|
|
|
|
// dto.IndexOptions = folder.IndexByOptionStrings.ToArray();
|
|
|
|
|
// }
|
|
|
|
|
//}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2014-03-02 22:11:03 -07:00
|
|
|
|
var supportsPlaceHolders = item as ISupportsPlaceHolders;
|
|
|
|
|
if (supportsPlaceHolders != null)
|
|
|
|
|
{
|
|
|
|
|
dto.IsPlaceHolder = supportsPlaceHolders.IsPlaceHolder;
|
|
|
|
|
}
|
2014-03-22 09:16:43 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
// Add audio info
|
|
|
|
|
var audio = item as Audio;
|
|
|
|
|
if (audio != null)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.Album = audio.Album;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2015-05-04 07:35:38 -07:00
|
|
|
|
var albumParent = audio.AlbumEntity;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (albumParent != null)
|
|
|
|
|
{
|
|
|
|
|
dto.AlbumId = GetDtoId(albumParent);
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2014-02-07 13:30:41 -07:00
|
|
|
|
dto.AlbumPrimaryImageTag = GetImageCacheTag(albumParent, ImageType.Primary);
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
2014-03-20 20:31:40 -07:00
|
|
|
|
|
2014-12-01 05:43:34 -07:00
|
|
|
|
//if (fields.Contains(ItemFields.MediaSourceCount))
|
|
|
|
|
//{
|
2015-01-24 12:03:55 -07:00
|
|
|
|
// Songs always have one
|
2014-12-01 05:43:34 -07:00
|
|
|
|
//}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
2015-03-13 10:25:28 -07:00
|
|
|
|
var hasArtist = item as IHasArtist;
|
|
|
|
|
if (hasArtist != null)
|
|
|
|
|
{
|
|
|
|
|
dto.Artists = hasArtist.Artists;
|
|
|
|
|
|
|
|
|
|
dto.ArtistItems = hasArtist
|
|
|
|
|
.Artists
|
|
|
|
|
.Select(i =>
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
var artist = _libraryManager.GetArtist(i);
|
|
|
|
|
return new NameIdPair
|
|
|
|
|
{
|
|
|
|
|
Name = artist.Name,
|
|
|
|
|
Id = artist.Id.ToString("N")
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting artist", ex);
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
.Where(i => i != null)
|
|
|
|
|
.ToList();
|
|
|
|
|
}
|
2013-09-06 12:17:15 -07:00
|
|
|
|
|
2015-03-13 10:25:28 -07:00
|
|
|
|
var hasAlbumArtist = item as IHasAlbumArtist;
|
2013-09-06 12:17:15 -07:00
|
|
|
|
if (hasAlbumArtist != null)
|
|
|
|
|
{
|
2014-06-23 09:05:19 -07:00
|
|
|
|
dto.AlbumArtist = hasAlbumArtist.AlbumArtists.FirstOrDefault();
|
2015-03-13 08:54:20 -07:00
|
|
|
|
|
|
|
|
|
dto.AlbumArtists = hasAlbumArtist
|
|
|
|
|
.AlbumArtists
|
|
|
|
|
.Select(i =>
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
var artist = _libraryManager.GetArtist(i);
|
|
|
|
|
return new NameIdPair
|
|
|
|
|
{
|
|
|
|
|
Name = artist.Name,
|
|
|
|
|
Id = artist.Id.ToString("N")
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting album artist", ex);
|
|
|
|
|
return null;
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
.Where(i => i != null)
|
|
|
|
|
.ToList();
|
2013-09-06 12:17:15 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
// Add video info
|
|
|
|
|
var video = item as Video;
|
|
|
|
|
if (video != null)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.VideoType = video.VideoType;
|
|
|
|
|
dto.Video3DFormat = video.Video3DFormat;
|
|
|
|
|
dto.IsoType = video.IsoType;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2015-10-24 08:33:22 -07:00
|
|
|
|
if (video.HasSubtitles)
|
|
|
|
|
{
|
|
|
|
|
dto.HasSubtitles = video.HasSubtitles;
|
|
|
|
|
}
|
|
|
|
|
|
2014-12-02 20:13:03 -07:00
|
|
|
|
if (video.AdditionalParts.Count != 0)
|
2014-11-30 12:01:33 -07:00
|
|
|
|
{
|
2014-12-02 20:13:03 -07:00
|
|
|
|
dto.PartCount = video.AdditionalParts.Count + 1;
|
2014-11-30 12:01:33 -07:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (fields.Contains(ItemFields.MediaSourceCount))
|
|
|
|
|
{
|
2014-12-01 05:43:34 -07:00
|
|
|
|
if (video.MediaSourceCount != 1)
|
|
|
|
|
{
|
|
|
|
|
dto.MediaSourceCount = video.MediaSourceCount;
|
|
|
|
|
}
|
2014-11-30 12:01:33 -07:00
|
|
|
|
}
|
2014-03-15 21:23:58 -07:00
|
|
|
|
|
2014-03-20 20:31:40 -07:00
|
|
|
|
if (fields.Contains(ItemFields.Chapters))
|
2014-03-20 08:55:22 -07:00
|
|
|
|
{
|
2014-10-12 08:18:26 -07:00
|
|
|
|
dto.Chapters = GetChapterInfoDtos(item);
|
2014-03-20 08:55:22 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (fields.Contains(ItemFields.MediaStreams))
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
// Add VideoInfo
|
2014-06-11 12:31:33 -07:00
|
|
|
|
var iHasMediaSources = item as IHasMediaSources;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2014-06-11 12:31:33 -07:00
|
|
|
|
if (iHasMediaSources != null)
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
2014-03-20 20:31:40 -07:00
|
|
|
|
List<MediaStream> mediaStreams;
|
|
|
|
|
|
2014-03-22 09:16:43 -07:00
|
|
|
|
if (dto.MediaSources != null && dto.MediaSources.Count > 0)
|
2013-12-05 20:39:44 -07:00
|
|
|
|
{
|
2014-03-22 09:31:21 -07:00
|
|
|
|
mediaStreams = dto.MediaSources.Where(i => new Guid(i.Id) == item.Id)
|
2014-03-20 20:31:40 -07:00
|
|
|
|
.SelectMany(i => i.MediaStreams)
|
|
|
|
|
.ToList();
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2015-03-31 09:24:16 -07:00
|
|
|
|
mediaStreams = _mediaSourceManager().GetStaticMediaSources(iHasMediaSources, true).First().MediaStreams;
|
2014-03-20 20:31:40 -07:00
|
|
|
|
}
|
2013-12-05 20:39:44 -07:00
|
|
|
|
|
2014-03-20 20:31:40 -07:00
|
|
|
|
dto.MediaStreams = mediaStreams;
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Add MovieInfo
|
|
|
|
|
var movie = item as Movie;
|
|
|
|
|
if (movie != null)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2014-09-20 08:48:23 -07:00
|
|
|
|
if (fields.Contains(ItemFields.TmdbCollectionName))
|
2013-07-05 17:19:44 -07:00
|
|
|
|
{
|
2014-09-20 08:48:23 -07:00
|
|
|
|
dto.TmdbCollectionName = movie.TmdbCollectionName;
|
2013-07-05 17:19:44 -07:00
|
|
|
|
}
|
2014-09-20 08:48:23 -07:00
|
|
|
|
}
|
2014-01-28 11:37:01 -07:00
|
|
|
|
|
2014-09-20 08:48:23 -07:00
|
|
|
|
var hasSpecialFeatures = item as IHasSpecialFeatures;
|
|
|
|
|
if (hasSpecialFeatures != null)
|
|
|
|
|
{
|
|
|
|
|
var specialFeatureCount = hasSpecialFeatures.SpecialFeatureIds.Count;
|
|
|
|
|
|
|
|
|
|
if (specialFeatureCount > 0)
|
2014-01-28 11:37:01 -07:00
|
|
|
|
{
|
2014-09-20 08:48:23 -07:00
|
|
|
|
dto.SpecialFeatureCount = specialFeatureCount;
|
2014-01-28 11:37:01 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
// Add EpisodeInfo
|
|
|
|
|
var episode = item as Episode;
|
|
|
|
|
if (episode != null)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.IndexNumberEnd = episode.IndexNumberEnd;
|
2013-12-08 13:33:24 -07:00
|
|
|
|
|
2014-12-01 05:43:34 -07:00
|
|
|
|
if (fields.Contains(ItemFields.AlternateEpisodeNumbers))
|
|
|
|
|
{
|
|
|
|
|
dto.DvdSeasonNumber = episode.DvdSeasonNumber;
|
|
|
|
|
dto.DvdEpisodeNumber = episode.DvdEpisodeNumber;
|
|
|
|
|
dto.AbsoluteEpisodeNumber = episode.AbsoluteEpisodeNumber;
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-11 22:07:19 -07:00
|
|
|
|
if (fields.Contains(ItemFields.SpecialEpisodeNumbers))
|
2014-12-18 21:20:07 -07:00
|
|
|
|
{
|
|
|
|
|
dto.AirsAfterSeasonNumber = episode.AirsAfterSeasonNumber;
|
|
|
|
|
dto.AirsBeforeEpisodeNumber = episode.AirsBeforeEpisodeNumber;
|
|
|
|
|
dto.AirsBeforeSeasonNumber = episode.AirsBeforeSeasonNumber;
|
|
|
|
|
}
|
2013-12-03 21:18:50 -07:00
|
|
|
|
|
2014-09-16 18:38:50 -07:00
|
|
|
|
var episodeSeason = episode.Season;
|
|
|
|
|
if (episodeSeason != null)
|
2013-12-03 21:18:50 -07:00
|
|
|
|
{
|
2014-09-16 18:38:50 -07:00
|
|
|
|
dto.SeasonId = episodeSeason.Id.ToString("N");
|
2014-12-18 21:20:07 -07:00
|
|
|
|
|
|
|
|
|
if (fields.Contains(ItemFields.SeasonName))
|
|
|
|
|
{
|
|
|
|
|
dto.SeasonName = episodeSeason.Name;
|
|
|
|
|
}
|
2013-12-03 21:18:50 -07:00
|
|
|
|
}
|
2014-12-12 20:56:30 -07:00
|
|
|
|
|
|
|
|
|
if (fields.Contains(ItemFields.SeriesGenres))
|
|
|
|
|
{
|
|
|
|
|
var episodeseries = episode.Series;
|
|
|
|
|
if (episodeseries != null)
|
|
|
|
|
{
|
|
|
|
|
dto.SeriesGenres = episodeseries.Genres.ToList();
|
|
|
|
|
}
|
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
// Add SeriesInfo
|
|
|
|
|
var series = item as Series;
|
|
|
|
|
if (series != null)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.AirDays = series.AirDays;
|
|
|
|
|
dto.AirTime = series.AirTime;
|
2015-05-31 11:22:51 -07:00
|
|
|
|
dto.SeriesStatus = series.Status;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2014-12-20 22:57:06 -07:00
|
|
|
|
if (fields.Contains(ItemFields.Settings))
|
2013-12-10 14:26:30 -07:00
|
|
|
|
{
|
|
|
|
|
dto.DisplaySpecialsWithSeasons = series.DisplaySpecialsWithSeasons;
|
|
|
|
|
}
|
2014-02-28 21:13:44 -07:00
|
|
|
|
|
|
|
|
|
dto.AnimeSeriesIndex = series.AnimeSeriesIndex;
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (episode != null)
|
2013-03-31 10:39:28 -07:00
|
|
|
|
{
|
2014-07-03 19:22:57 -07:00
|
|
|
|
series = episode.Series;
|
2013-09-04 10:02:19 -07:00
|
|
|
|
|
2014-07-03 19:22:57 -07:00
|
|
|
|
if (series != null)
|
|
|
|
|
{
|
|
|
|
|
dto.SeriesId = GetDtoId(series);
|
|
|
|
|
dto.SeriesName = series.Name;
|
2014-12-18 21:20:07 -07:00
|
|
|
|
|
|
|
|
|
if (fields.Contains(ItemFields.AirTime))
|
|
|
|
|
{
|
|
|
|
|
dto.AirTime = series.AirTime;
|
|
|
|
|
}
|
2014-12-01 05:43:34 -07:00
|
|
|
|
|
|
|
|
|
if (options.GetImageLimit(ImageType.Thumb) > 0)
|
|
|
|
|
{
|
|
|
|
|
dto.SeriesThumbImageTag = GetImageCacheTag(series, ImageType.Thumb);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (options.GetImageLimit(ImageType.Primary) > 0)
|
|
|
|
|
{
|
|
|
|
|
dto.SeriesPrimaryImageTag = GetImageCacheTag(series, ImageType.Primary);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (fields.Contains(ItemFields.SeriesStudio))
|
|
|
|
|
{
|
|
|
|
|
dto.SeriesStudio = series.Studios.FirstOrDefault();
|
|
|
|
|
}
|
2014-07-03 19:22:57 -07:00
|
|
|
|
}
|
2013-03-31 10:39:28 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
// Add SeasonInfo
|
|
|
|
|
var season = item as Season;
|
|
|
|
|
if (season != null)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2014-07-03 19:22:57 -07:00
|
|
|
|
series = season.Series;
|
2013-09-04 10:02:19 -07:00
|
|
|
|
|
2014-07-03 19:22:57 -07:00
|
|
|
|
if (series != null)
|
|
|
|
|
{
|
|
|
|
|
dto.SeriesId = GetDtoId(series);
|
|
|
|
|
dto.SeriesName = series.Name;
|
|
|
|
|
dto.AirTime = series.AirTime;
|
|
|
|
|
dto.SeriesStudio = series.Studios.FirstOrDefault();
|
2013-11-09 11:44:09 -07:00
|
|
|
|
|
2014-12-01 05:43:34 -07:00
|
|
|
|
if (options.GetImageLimit(ImageType.Primary) > 0)
|
|
|
|
|
{
|
|
|
|
|
dto.SeriesPrimaryImageTag = GetImageCacheTag(series, ImageType.Primary);
|
|
|
|
|
}
|
2014-07-03 19:22:57 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
var game = item as Game;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (game != null)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
SetGameProperties(dto, game);
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-10-27 14:40:42 -07:00
|
|
|
|
var gameSystem = item as GameSystem;
|
|
|
|
|
|
|
|
|
|
if (gameSystem != null)
|
|
|
|
|
{
|
|
|
|
|
SetGameSystemProperties(dto, gameSystem);
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
var musicVideo = item as MusicVideo;
|
|
|
|
|
if (musicVideo != null)
|
|
|
|
|
{
|
|
|
|
|
SetMusicVideoProperties(dto, musicVideo);
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
var book = item as Book;
|
|
|
|
|
if (book != null)
|
|
|
|
|
{
|
|
|
|
|
SetBookProperties(dto, book);
|
|
|
|
|
}
|
2014-03-30 09:49:40 -07:00
|
|
|
|
|
2014-08-28 17:49:25 -07:00
|
|
|
|
var photo = item as Photo;
|
|
|
|
|
if (photo != null)
|
|
|
|
|
{
|
|
|
|
|
SetPhotoProperties(dto, photo);
|
|
|
|
|
}
|
2014-03-30 09:49:40 -07:00
|
|
|
|
|
2015-08-16 21:08:33 -07:00
|
|
|
|
dto.ChannelId = item.ChannelId;
|
2015-10-29 06:28:05 -07:00
|
|
|
|
|
2014-05-17 14:23:48 -07:00
|
|
|
|
var channelItem = item as IChannelItem;
|
|
|
|
|
if (channelItem != null)
|
|
|
|
|
{
|
2014-05-19 12:51:56 -07:00
|
|
|
|
dto.ChannelName = _channelManagerFactory().GetChannel(channelItem.ChannelId).Name;
|
2014-05-17 14:23:48 -07:00
|
|
|
|
}
|
2014-10-20 13:23:40 -07:00
|
|
|
|
|
|
|
|
|
var channelMediaItem = item as IChannelMediaItem;
|
|
|
|
|
if (channelMediaItem != null)
|
|
|
|
|
{
|
|
|
|
|
dto.ExtraType = channelMediaItem.ExtraType;
|
|
|
|
|
}
|
2014-03-30 09:49:40 -07:00
|
|
|
|
}
|
|
|
|
|
|
2014-11-30 12:01:33 -07:00
|
|
|
|
private void AttachLinkedChildImages(BaseItemDto dto, Folder folder, User user, DtoOptions options)
|
2014-08-02 19:16:37 -07:00
|
|
|
|
{
|
|
|
|
|
List<BaseItem> linkedChildren = null;
|
|
|
|
|
|
2014-11-30 12:01:33 -07:00
|
|
|
|
var backdropLimit = options.GetImageLimit(ImageType.Backdrop);
|
|
|
|
|
|
|
|
|
|
if (backdropLimit > 0 && dto.BackdropImageTags.Count == 0)
|
2014-08-02 19:16:37 -07:00
|
|
|
|
{
|
2014-11-30 12:01:33 -07:00
|
|
|
|
linkedChildren = user == null
|
|
|
|
|
? folder.GetRecursiveChildren().ToList()
|
2015-01-24 23:34:50 -07:00
|
|
|
|
: folder.GetRecursiveChildren(user).ToList();
|
2014-11-30 12:01:33 -07:00
|
|
|
|
|
2014-08-02 19:16:37 -07:00
|
|
|
|
var parentWithBackdrop = linkedChildren.FirstOrDefault(i => i.GetImages(ImageType.Backdrop).Any());
|
|
|
|
|
|
|
|
|
|
if (parentWithBackdrop != null)
|
|
|
|
|
{
|
|
|
|
|
dto.ParentBackdropItemId = GetDtoId(parentWithBackdrop);
|
2014-11-30 12:01:33 -07:00
|
|
|
|
dto.ParentBackdropImageTags = GetBackdropImageTags(parentWithBackdrop, backdropLimit);
|
2014-08-02 19:16:37 -07:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-11-30 12:01:33 -07:00
|
|
|
|
if (!dto.ImageTags.ContainsKey(ImageType.Primary) && options.GetImageLimit(ImageType.Primary) > 0)
|
2014-08-02 19:16:37 -07:00
|
|
|
|
{
|
|
|
|
|
if (linkedChildren == null)
|
|
|
|
|
{
|
|
|
|
|
linkedChildren = user == null
|
|
|
|
|
? folder.GetRecursiveChildren().ToList()
|
2015-01-24 23:34:50 -07:00
|
|
|
|
: folder.GetRecursiveChildren(user).ToList();
|
2014-08-02 19:16:37 -07:00
|
|
|
|
}
|
|
|
|
|
var parentWithImage = linkedChildren.FirstOrDefault(i => i.GetImages(ImageType.Primary).Any());
|
|
|
|
|
|
|
|
|
|
if (parentWithImage != null)
|
|
|
|
|
{
|
|
|
|
|
dto.ParentPrimaryImageItemId = GetDtoId(parentWithImage);
|
|
|
|
|
dto.ParentPrimaryImageTag = GetImageCacheTag(parentWithImage, ImageType.Primary);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-20 20:31:40 -07:00
|
|
|
|
private string GetMappedPath(IHasMetadata item)
|
2014-03-20 08:55:22 -07:00
|
|
|
|
{
|
2014-03-20 20:31:40 -07:00
|
|
|
|
var path = item.Path;
|
2014-03-20 08:55:22 -07:00
|
|
|
|
|
2014-03-20 20:31:40 -07:00
|
|
|
|
var locationType = item.LocationType;
|
2014-03-20 08:55:22 -07:00
|
|
|
|
|
2014-06-02 12:32:41 -07:00
|
|
|
|
if (locationType == LocationType.FileSystem || locationType == LocationType.Offline)
|
2014-03-20 08:55:22 -07:00
|
|
|
|
{
|
2014-06-02 12:32:41 -07:00
|
|
|
|
foreach (var map in _config.Configuration.PathSubstitutions)
|
|
|
|
|
{
|
2015-10-03 20:38:46 -07:00
|
|
|
|
path = _libraryManager.SubstitutePath(path, map.From, map.To);
|
2014-06-02 12:32:41 -07:00
|
|
|
|
}
|
2014-03-20 08:55:22 -07:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return path;
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-05 09:50:21 -07:00
|
|
|
|
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-20 18:33:05 -07:00
|
|
|
|
/// <summary>
|
2013-09-04 10:02:19 -07: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-20 18:33:05 -07:00
|
|
|
|
/// </summary>
|
2013-09-04 10:02:19 -07:00
|
|
|
|
/// <param name="folder">The folder.</param>
|
|
|
|
|
/// <param name="user">The user.</param>
|
|
|
|
|
/// <param name="dto">The dto.</param>
|
2013-09-23 07:26:20 -07:00
|
|
|
|
/// <param name="fields">The fields.</param>
|
2015-06-02 10:46:44 -07:00
|
|
|
|
/// <param name="syncProgress">The synchronize progress.</param>
|
2013-09-04 10:02:19 -07:00
|
|
|
|
/// <returns>Task.</returns>
|
2015-07-26 22:03:34 -07:00
|
|
|
|
private void SetSpecialCounts(Folder folder, User user, BaseItemDto dto, List<ItemFields> fields, Dictionary<string, SyncedItemProgress> syncProgress)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2013-09-04 10:02:19 -07:00
|
|
|
|
var recursiveItemCount = 0;
|
|
|
|
|
var unplayed = 0;
|
|
|
|
|
long runtime = 0;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2014-02-10 11:43:33 -07:00
|
|
|
|
DateTime? dateLastMediaAdded = null;
|
2013-09-04 10:02:19 -07:00
|
|
|
|
double totalPercentPlayed = 0;
|
2015-06-02 10:46:44 -07:00
|
|
|
|
double totalSyncPercent = 0;
|
|
|
|
|
var addSyncInfo = fields.Contains(ItemFields.SyncInfo);
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2015-07-26 22:03:34 -07:00
|
|
|
|
var children = folder.GetItems(new InternalItemsQuery
|
2013-12-10 13:42:42 -07:00
|
|
|
|
{
|
2015-07-26 22:03:34 -07:00
|
|
|
|
IsFolder = false,
|
|
|
|
|
Recursive = true,
|
|
|
|
|
IsVirtualUnaired = false,
|
2015-08-16 21:56:22 -07:00
|
|
|
|
IsMissing = false,
|
|
|
|
|
User = user
|
2015-07-26 22:03:34 -07:00
|
|
|
|
|
|
|
|
|
}).Result.Items;
|
2013-12-10 13:42:42 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
// Loop through each recursive child
|
2013-12-10 13:42:42 -07:00
|
|
|
|
foreach (var child in children)
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
2014-02-10 11:43:33 -07:00
|
|
|
|
if (!dateLastMediaAdded.HasValue)
|
|
|
|
|
{
|
|
|
|
|
dateLastMediaAdded = child.DateCreated;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
dateLastMediaAdded = new[] { dateLastMediaAdded.Value, child.DateCreated }.Max();
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
var userdata = _userDataRepository.GetUserData(user.Id, child.GetUserDataKey());
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
recursiveItemCount++;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
var isUnplayed = true;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
// Incrememt totalPercentPlayed
|
|
|
|
|
if (userdata != null)
|
|
|
|
|
{
|
|
|
|
|
if (userdata.Played)
|
|
|
|
|
{
|
|
|
|
|
totalPercentPlayed += 100;
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07: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-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
if (isUnplayed)
|
|
|
|
|
{
|
|
|
|
|
unplayed++;
|
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
runtime += child.RunTimeTicks ?? 0;
|
2015-06-02 10:46:44 -07:00
|
|
|
|
|
|
|
|
|
if (addSyncInfo)
|
|
|
|
|
{
|
|
|
|
|
double percent = 0;
|
|
|
|
|
SyncedItemProgress syncItemProgress;
|
2015-06-02 10:50:50 -07:00
|
|
|
|
if (syncProgress.TryGetValue(child.Id.ToString("N"), out syncItemProgress))
|
2015-06-02 10:46:44 -07:00
|
|
|
|
{
|
|
|
|
|
switch (syncItemProgress.Status)
|
|
|
|
|
{
|
|
|
|
|
case SyncJobItemStatus.Synced:
|
|
|
|
|
percent = 100;
|
|
|
|
|
break;
|
|
|
|
|
case SyncJobItemStatus.Converting:
|
|
|
|
|
case SyncJobItemStatus.ReadyToTransfer:
|
|
|
|
|
case SyncJobItemStatus.Transferring:
|
|
|
|
|
percent = 50;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
totalSyncPercent += percent;
|
|
|
|
|
}
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
|
2013-09-04 10:02:19 -07:00
|
|
|
|
dto.RecursiveItemCount = recursiveItemCount;
|
2014-08-16 22:38:13 -07:00
|
|
|
|
dto.UserData.UnplayedItemCount = unplayed;
|
2013-09-04 10:02:19 -07:00
|
|
|
|
|
|
|
|
|
if (recursiveItemCount > 0)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2014-08-16 22:38:13 -07:00
|
|
|
|
dto.UserData.PlayedPercentage = totalPercentPlayed / recursiveItemCount;
|
2015-06-02 10:46:44 -07:00
|
|
|
|
|
|
|
|
|
if (addSyncInfo)
|
|
|
|
|
{
|
2015-06-02 10:50:50 -07:00
|
|
|
|
var pct = totalSyncPercent / recursiveItemCount;
|
|
|
|
|
if (pct > 0)
|
|
|
|
|
{
|
|
|
|
|
dto.SyncPercent = pct;
|
|
|
|
|
}
|
2015-06-02 10:46:44 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-23 07:26:20 -07:00
|
|
|
|
if (runtime > 0 && fields.Contains(ItemFields.CumulativeRunTimeTicks))
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
|
|
|
|
dto.CumulativeRunTimeTicks = runtime;
|
|
|
|
|
}
|
2014-02-10 11:43:33 -07:00
|
|
|
|
|
|
|
|
|
if (fields.Contains(ItemFields.DateLastMediaAdded))
|
|
|
|
|
{
|
|
|
|
|
dto.DateLastMediaAdded = dateLastMediaAdded;
|
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
2013-09-04 10:02:19 -07:00
|
|
|
|
/// Attaches the primary image aspect ratio.
|
2013-02-20 18:33:05 -07:00
|
|
|
|
/// </summary>
|
2013-09-04 10:02:19 -07:00
|
|
|
|
/// <param name="dto">The dto.</param>
|
2013-02-20 18:33:05 -07:00
|
|
|
|
/// <param name="item">The item.</param>
|
2013-09-04 10:02:19 -07:00
|
|
|
|
/// <returns>Task.</returns>
|
2016-01-15 22:01:57 -07:00
|
|
|
|
public void AttachPrimaryImageAspectRatio(IItemDto dto, IHasImages item)
|
|
|
|
|
{
|
|
|
|
|
dto.PrimaryImageAspectRatio = GetPrimaryImageAspectRatio(item);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public double? GetPrimaryImageAspectRatio(IHasImages item)
|
2013-02-20 18:33:05 -07:00
|
|
|
|
{
|
2014-02-07 13:30:41 -07:00
|
|
|
|
var imageInfo = item.GetImageInfo(ImageType.Primary, 0);
|
2013-05-04 21:49:49 -07:00
|
|
|
|
|
2015-10-16 10:06:31 -07:00
|
|
|
|
if (imageInfo == null || !imageInfo.IsLocalFile)
|
2013-09-04 10:02:19 -07:00
|
|
|
|
{
|
2016-01-15 22:01:57 -07:00
|
|
|
|
return null;
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ImageSize size;
|
2013-07-05 17:19:44 -07:00
|
|
|
|
|
2014-10-14 17:05:09 -07:00
|
|
|
|
try
|
2013-05-04 21:49:49 -07:00
|
|
|
|
{
|
2015-02-28 06:42:47 -07:00
|
|
|
|
size = _imageProcessor.GetImageSize(imageInfo);
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
2014-10-14 17:05:09 -07:00
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
2015-08-14 10:24:07 -07:00
|
|
|
|
//_logger.ErrorException("Failed to determine primary image aspect ratio for {0}", ex, path);
|
2016-01-15 22:01:57 -07:00
|
|
|
|
return null;
|
2013-09-04 10:02:19 -07:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-18 11:49:06 -07:00
|
|
|
|
var supportedEnhancers = _imageProcessor.GetSupportedEnhancers(item, ImageType.Primary).ToList();
|
2013-09-04 10:02:19 -07: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-04 21:49:49 -07:00
|
|
|
|
}
|
2013-09-04 10:02:19 -07:00
|
|
|
|
|
2016-01-21 01:23:02 -07:00
|
|
|
|
var width = size.Width;
|
|
|
|
|
var height = size.Height;
|
|
|
|
|
|
|
|
|
|
if (width == 0 || height == 0)
|
2015-01-30 14:17:19 -07:00
|
|
|
|
{
|
2016-01-21 01:23:02 -07:00
|
|
|
|
return null;
|
2015-01-30 14:17:19 -07:00
|
|
|
|
}
|
2016-01-21 01:23:02 -07:00
|
|
|
|
|
|
|
|
|
var photo = item as Photo;
|
|
|
|
|
if (photo != null && photo.Orientation.HasValue)
|
|
|
|
|
{
|
|
|
|
|
switch (photo.Orientation.Value)
|
|
|
|
|
{
|
|
|
|
|
case ImageOrientation.LeftBottom:
|
|
|
|
|
case ImageOrientation.LeftTop:
|
|
|
|
|
case ImageOrientation.RightBottom:
|
|
|
|
|
case ImageOrientation.RightTop:
|
|
|
|
|
var temp = height;
|
|
|
|
|
height = width;
|
|
|
|
|
width = temp;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return width / height;
|
2013-05-04 21:49:49 -07:00
|
|
|
|
}
|
2013-02-20 18:33:05 -07:00
|
|
|
|
}
|
|
|
|
|
}
|