2015-08-19 19:57:27 -04:00
|
|
|
|
using MediaBrowser.Common;
|
2014-10-29 21:17:31 -04:00
|
|
|
|
using MediaBrowser.Common.Configuration;
|
2014-07-27 18:01:29 -04:00
|
|
|
|
using MediaBrowser.Common.Extensions;
|
2015-08-18 11:25:57 -04:00
|
|
|
|
using MediaBrowser.Common.IO;
|
2015-02-10 14:47:54 -05:00
|
|
|
|
using MediaBrowser.Common.Progress;
|
2014-01-15 00:38:08 -05:00
|
|
|
|
using MediaBrowser.Common.ScheduledTasks;
|
2014-01-12 11:55:38 -05:00
|
|
|
|
using MediaBrowser.Controller.Configuration;
|
2013-11-24 15:51:45 -05:00
|
|
|
|
using MediaBrowser.Controller.Drawing;
|
2013-11-25 21:53:48 -05:00
|
|
|
|
using MediaBrowser.Controller.Dto;
|
|
|
|
|
using MediaBrowser.Controller.Entities;
|
|
|
|
|
using MediaBrowser.Controller.Library;
|
2013-11-24 15:51:45 -05:00
|
|
|
|
using MediaBrowser.Controller.LiveTv;
|
2014-06-07 15:46:24 -04:00
|
|
|
|
using MediaBrowser.Controller.Localization;
|
2013-11-24 15:51:45 -05:00
|
|
|
|
using MediaBrowser.Controller.Persistence;
|
2014-01-28 13:37:01 -05:00
|
|
|
|
using MediaBrowser.Controller.Providers;
|
2014-01-13 11:25:18 -05:00
|
|
|
|
using MediaBrowser.Controller.Sorting;
|
2015-07-28 08:33:30 -04:00
|
|
|
|
using MediaBrowser.Model.Configuration;
|
2014-06-07 15:46:24 -04:00
|
|
|
|
using MediaBrowser.Model.Dto;
|
2014-01-01 13:26:31 -05:00
|
|
|
|
using MediaBrowser.Model.Entities;
|
2013-09-26 11:48:14 -04:00
|
|
|
|
using MediaBrowser.Model.LiveTv;
|
2013-11-24 15:51:45 -05:00
|
|
|
|
using MediaBrowser.Model.Logging;
|
2013-11-25 16:53:06 -05:00
|
|
|
|
using MediaBrowser.Model.Querying;
|
2014-08-15 12:35:41 -04:00
|
|
|
|
using MediaBrowser.Model.Serialization;
|
2015-08-12 17:39:02 -04:00
|
|
|
|
using MoreLinq;
|
2013-11-24 15:51:45 -05:00
|
|
|
|
using System;
|
2014-01-12 01:31:21 -05:00
|
|
|
|
using System.Collections.Concurrent;
|
2013-09-26 11:48:14 -04:00
|
|
|
|
using System.Collections.Generic;
|
2015-08-19 19:57:27 -04:00
|
|
|
|
using System.IO;
|
2013-11-24 15:51:45 -05:00
|
|
|
|
using System.Linq;
|
|
|
|
|
using System.Threading;
|
|
|
|
|
using System.Threading.Tasks;
|
2015-10-04 00:23:11 -04:00
|
|
|
|
using CommonIO;
|
2013-09-26 11:48:14 -04:00
|
|
|
|
|
|
|
|
|
namespace MediaBrowser.Server.Implementations.LiveTv
|
|
|
|
|
{
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Class LiveTvManager
|
|
|
|
|
/// </summary>
|
2014-01-12 01:31:21 -05:00
|
|
|
|
public class LiveTvManager : ILiveTvManager, IDisposable
|
2013-09-26 11:48:14 -04:00
|
|
|
|
{
|
2014-01-12 11:55:38 -05:00
|
|
|
|
private readonly IServerConfigurationManager _config;
|
2013-11-24 15:51:45 -05:00
|
|
|
|
private readonly ILogger _logger;
|
|
|
|
|
private readonly IItemRepository _itemRepo;
|
2013-11-25 21:53:48 -05:00
|
|
|
|
private readonly IUserManager _userManager;
|
2014-01-12 10:58:47 -05:00
|
|
|
|
private readonly IUserDataManager _userDataManager;
|
2014-01-11 00:49:18 -05:00
|
|
|
|
private readonly ILibraryManager _libraryManager;
|
2014-01-15 00:38:08 -05:00
|
|
|
|
private readonly ITaskManager _taskManager;
|
2014-08-15 12:35:41 -04:00
|
|
|
|
private readonly IJsonSerializer _jsonSerializer;
|
2015-03-14 16:00:32 -04:00
|
|
|
|
private readonly IProviderManager _providerManager;
|
2013-12-14 20:17:57 -05:00
|
|
|
|
|
2014-06-07 15:46:24 -04:00
|
|
|
|
private readonly IDtoService _dtoService;
|
|
|
|
|
private readonly ILocalizationManager _localization;
|
|
|
|
|
|
2013-12-14 20:17:57 -05:00
|
|
|
|
private readonly LiveTvDtoService _tvDtoService;
|
2013-11-25 21:53:48 -05:00
|
|
|
|
|
2013-09-26 11:48:14 -04:00
|
|
|
|
private readonly List<ILiveTvService> _services = new List<ILiveTvService>();
|
2013-11-24 15:51:45 -05:00
|
|
|
|
|
2014-07-02 14:34:08 -04:00
|
|
|
|
private readonly ConcurrentDictionary<string, LiveStreamData> _openStreams =
|
|
|
|
|
new ConcurrentDictionary<string, LiveStreamData>();
|
2014-01-12 01:31:21 -05:00
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
private readonly SemaphoreSlim _refreshRecordingsLock = new SemaphoreSlim(1, 1);
|
|
|
|
|
|
2015-07-23 09:23:22 -04:00
|
|
|
|
private readonly List<ITunerHost> _tunerHosts = new List<ITunerHost>();
|
|
|
|
|
private readonly List<IListingsProvider> _listingProviders = new List<IListingsProvider>();
|
2015-08-18 11:25:57 -04:00
|
|
|
|
private readonly IFileSystem _fileSystem;
|
2015-07-23 09:23:22 -04:00
|
|
|
|
|
2015-08-18 11:25:57 -04:00
|
|
|
|
public LiveTvManager(IApplicationHost appHost, IServerConfigurationManager config, ILogger logger, IItemRepository itemRepo, IImageProcessor imageProcessor, IUserDataManager userDataManager, IDtoService dtoService, IUserManager userManager, ILibraryManager libraryManager, ITaskManager taskManager, ILocalizationManager localization, IJsonSerializer jsonSerializer, IProviderManager providerManager, IFileSystem fileSystem)
|
2013-11-24 15:51:45 -05:00
|
|
|
|
{
|
2014-01-12 11:55:38 -05:00
|
|
|
|
_config = config;
|
2013-11-24 15:51:45 -05:00
|
|
|
|
_logger = logger;
|
|
|
|
|
_itemRepo = itemRepo;
|
2013-12-14 20:17:57 -05:00
|
|
|
|
_userManager = userManager;
|
2014-01-11 00:49:18 -05:00
|
|
|
|
_libraryManager = libraryManager;
|
2014-01-15 10:18:31 -05:00
|
|
|
|
_taskManager = taskManager;
|
2014-06-07 15:46:24 -04:00
|
|
|
|
_localization = localization;
|
2014-08-15 12:35:41 -04:00
|
|
|
|
_jsonSerializer = jsonSerializer;
|
2015-03-14 16:00:32 -04:00
|
|
|
|
_providerManager = providerManager;
|
2015-08-18 11:25:57 -04:00
|
|
|
|
_fileSystem = fileSystem;
|
2014-06-07 15:46:24 -04:00
|
|
|
|
_dtoService = dtoService;
|
2014-01-12 10:58:47 -05:00
|
|
|
|
_userDataManager = userDataManager;
|
2013-12-14 20:17:57 -05:00
|
|
|
|
|
2014-10-29 21:17:31 -04:00
|
|
|
|
_tvDtoService = new LiveTvDtoService(dtoService, userDataManager, imageProcessor, logger, appHost);
|
2013-11-24 15:51:45 -05:00
|
|
|
|
}
|
|
|
|
|
|
2013-09-26 11:48:14 -04:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Gets the services.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <value>The services.</value>
|
|
|
|
|
public IReadOnlyList<ILiveTvService> Services
|
|
|
|
|
{
|
|
|
|
|
get { return _services; }
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-27 18:01:29 -04:00
|
|
|
|
private LiveTvOptions GetConfiguration()
|
|
|
|
|
{
|
|
|
|
|
return _config.GetConfiguration<LiveTvOptions>("livetv");
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-26 11:48:14 -04:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Adds the parts.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="services">The services.</param>
|
2015-07-23 09:23:22 -04:00
|
|
|
|
/// <param name="tunerHosts">The tuner hosts.</param>
|
|
|
|
|
/// <param name="listingProviders">The listing providers.</param>
|
|
|
|
|
public void AddParts(IEnumerable<ILiveTvService> services, IEnumerable<ITunerHost> tunerHosts, IEnumerable<IListingsProvider> listingProviders)
|
2013-09-26 11:48:14 -04:00
|
|
|
|
{
|
|
|
|
|
_services.AddRange(services);
|
2015-07-23 09:23:22 -04:00
|
|
|
|
_tunerHosts.AddRange(tunerHosts);
|
|
|
|
|
_listingProviders.AddRange(listingProviders);
|
2013-12-04 15:55:42 -05:00
|
|
|
|
|
2015-03-12 11:51:48 -04:00
|
|
|
|
foreach (var service in _services)
|
2014-01-15 00:38:08 -05:00
|
|
|
|
{
|
|
|
|
|
service.DataSourceChanged += service_DataSourceChanged;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-23 09:23:22 -04:00
|
|
|
|
public List<ITunerHost> TunerHosts
|
|
|
|
|
{
|
|
|
|
|
get { return _tunerHosts; }
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public List<IListingsProvider> ListingProviders
|
|
|
|
|
{
|
|
|
|
|
get { return _listingProviders; }
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-15 00:38:08 -05:00
|
|
|
|
void service_DataSourceChanged(object sender, EventArgs e)
|
|
|
|
|
{
|
|
|
|
|
_taskManager.CancelIfRunningAndQueue<RefreshChannelsScheduledTask>();
|
2013-09-26 11:48:14 -04:00
|
|
|
|
}
|
|
|
|
|
|
2014-08-14 09:24:30 -04:00
|
|
|
|
public async Task<QueryResult<LiveTvChannel>> GetInternalChannels(LiveTvChannelQuery query, CancellationToken cancellationToken)
|
2013-11-24 15:51:45 -05:00
|
|
|
|
{
|
2014-09-14 11:10:51 -04:00
|
|
|
|
var user = string.IsNullOrEmpty(query.UserId) ? null : _userManager.GetUserById(query.UserId);
|
2013-11-25 21:53:48 -05:00
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
var channels = _libraryManager.GetItems(new InternalItemsQuery
|
|
|
|
|
{
|
|
|
|
|
IncludeItemTypes = new[] { typeof(LiveTvChannel).Name }
|
|
|
|
|
|
|
|
|
|
}).Items.Cast<LiveTvChannel>();
|
2013-11-25 21:53:48 -05:00
|
|
|
|
|
|
|
|
|
if (user != null)
|
|
|
|
|
{
|
2014-01-02 23:58:22 -05:00
|
|
|
|
// Avoid implicitly captured closure
|
|
|
|
|
var currentUser = user;
|
|
|
|
|
|
2013-12-19 16:51:32 -05:00
|
|
|
|
channels = channels
|
2015-02-03 16:06:56 -05:00
|
|
|
|
.Where(i => i.IsVisible(currentUser))
|
2013-11-25 21:53:48 -05:00
|
|
|
|
.OrderBy(i =>
|
|
|
|
|
{
|
|
|
|
|
double number = 0;
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
if (!string.IsNullOrEmpty(i.Number))
|
2013-11-25 21:53:48 -05:00
|
|
|
|
{
|
2014-01-23 13:05:41 -05:00
|
|
|
|
double.TryParse(i.Number, out number);
|
2013-11-25 21:53:48 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return number;
|
|
|
|
|
|
|
|
|
|
});
|
2014-03-28 22:28:02 -04:00
|
|
|
|
|
|
|
|
|
if (query.IsFavorite.HasValue)
|
|
|
|
|
{
|
|
|
|
|
var val = query.IsFavorite.Value;
|
|
|
|
|
|
|
|
|
|
channels = channels
|
|
|
|
|
.Where(i => _userDataManager.GetUserData(user.Id, i.GetUserDataKey()).IsFavorite == val);
|
|
|
|
|
}
|
2014-05-23 19:58:28 -04:00
|
|
|
|
|
|
|
|
|
if (query.IsLiked.HasValue)
|
|
|
|
|
{
|
|
|
|
|
var val = query.IsLiked.Value;
|
|
|
|
|
|
|
|
|
|
channels = channels
|
|
|
|
|
.Where(i =>
|
|
|
|
|
{
|
|
|
|
|
var likes = _userDataManager.GetUserData(user.Id, i.GetUserDataKey()).Likes;
|
|
|
|
|
|
|
|
|
|
return likes.HasValue && likes.Value == val;
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (query.IsDisliked.HasValue)
|
|
|
|
|
{
|
|
|
|
|
var val = query.IsDisliked.Value;
|
|
|
|
|
|
|
|
|
|
channels = channels
|
|
|
|
|
.Where(i =>
|
|
|
|
|
{
|
|
|
|
|
var likes = _userDataManager.GetUserData(user.Id, i.GetUserDataKey()).Likes;
|
|
|
|
|
|
|
|
|
|
return likes.HasValue && likes.Value != val;
|
|
|
|
|
});
|
|
|
|
|
}
|
2013-11-25 21:53:48 -05:00
|
|
|
|
}
|
|
|
|
|
|
2014-09-25 23:47:46 -04:00
|
|
|
|
var enableFavoriteSorting = query.EnableFavoriteSorting;
|
|
|
|
|
|
2014-01-10 08:52:01 -05:00
|
|
|
|
channels = channels.OrderBy(i =>
|
2014-09-25 23:47:46 -04:00
|
|
|
|
{
|
|
|
|
|
if (enableFavoriteSorting)
|
|
|
|
|
{
|
|
|
|
|
var userData = _userDataManager.GetUserData(user.Id, i.GetUserDataKey());
|
|
|
|
|
|
|
|
|
|
if (userData.IsFavorite)
|
|
|
|
|
{
|
|
|
|
|
return 0;
|
|
|
|
|
}
|
|
|
|
|
if (userData.Likes.HasValue)
|
|
|
|
|
{
|
|
|
|
|
if (!userData.Likes.Value)
|
|
|
|
|
{
|
|
|
|
|
return 3;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return 2;
|
2014-12-08 23:57:18 -05:00
|
|
|
|
});
|
2014-01-10 08:52:01 -05:00
|
|
|
|
|
|
|
|
|
var allChannels = channels.ToList();
|
|
|
|
|
IEnumerable<LiveTvChannel> allEnumerable = allChannels;
|
|
|
|
|
|
|
|
|
|
if (query.StartIndex.HasValue)
|
|
|
|
|
{
|
|
|
|
|
allEnumerable = allEnumerable.Skip(query.StartIndex.Value);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (query.Limit.HasValue)
|
|
|
|
|
{
|
|
|
|
|
allEnumerable = allEnumerable.Take(query.Limit.Value);
|
|
|
|
|
}
|
|
|
|
|
|
2014-08-14 09:24:30 -04:00
|
|
|
|
var result = new QueryResult<LiveTvChannel>
|
|
|
|
|
{
|
|
|
|
|
Items = allEnumerable.ToArray(),
|
|
|
|
|
TotalRecordCount = allChannels.Count
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-02 13:02:23 -04:00
|
|
|
|
public async Task<QueryResult<ChannelInfoDto>> GetChannels(LiveTvChannelQuery query, DtoOptions options, CancellationToken cancellationToken)
|
2014-08-14 09:24:30 -04:00
|
|
|
|
{
|
2014-09-14 11:10:51 -04:00
|
|
|
|
var user = string.IsNullOrEmpty(query.UserId) ? null : _userManager.GetUserById(query.UserId);
|
2014-08-14 09:24:30 -04:00
|
|
|
|
|
|
|
|
|
var internalResult = await GetInternalChannels(query, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
2014-03-09 18:14:44 -04:00
|
|
|
|
var returnList = new List<ChannelInfoDto>();
|
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
var now = DateTime.UtcNow;
|
|
|
|
|
|
2015-08-24 23:13:04 -04:00
|
|
|
|
var programs = query.AddCurrentProgram ? _libraryManager.QueryItems(new InternalItemsQuery
|
2015-06-01 10:49:23 -04:00
|
|
|
|
{
|
|
|
|
|
IncludeItemTypes = new[] { typeof(LiveTvProgram).Name },
|
|
|
|
|
MaxStartDate = now,
|
2015-08-24 23:13:04 -04:00
|
|
|
|
MinEndDate = now,
|
|
|
|
|
ChannelIds = internalResult.Items.Select(i => i.Id.ToString("N")).ToArray()
|
2015-06-01 10:49:23 -04:00
|
|
|
|
|
2015-08-24 23:13:04 -04:00
|
|
|
|
}).Items.Cast<LiveTvProgram>().OrderBy(i => i.StartDate).ToList() : new List<LiveTvProgram>();
|
2015-06-01 10:49:23 -04:00
|
|
|
|
|
2014-08-14 09:24:30 -04:00
|
|
|
|
foreach (var channel in internalResult.Items)
|
2014-03-09 18:14:44 -04:00
|
|
|
|
{
|
2015-06-01 10:49:23 -04:00
|
|
|
|
var channelIdString = channel.Id.ToString("N");
|
|
|
|
|
var currentProgram = programs.FirstOrDefault(i => string.Equals(i.ChannelId, channelIdString, StringComparison.OrdinalIgnoreCase));
|
2014-03-09 18:14:44 -04:00
|
|
|
|
|
2015-08-02 13:02:23 -04:00
|
|
|
|
returnList.Add(_tvDtoService.GetChannelInfoDto(channel, options, currentProgram, user));
|
2014-03-09 18:14:44 -04:00
|
|
|
|
}
|
2013-11-25 15:39:23 -05:00
|
|
|
|
|
2013-12-14 20:17:57 -05:00
|
|
|
|
var result = new QueryResult<ChannelInfoDto>
|
2013-11-25 15:39:23 -05:00
|
|
|
|
{
|
2014-03-09 18:14:44 -04:00
|
|
|
|
Items = returnList.ToArray(),
|
2014-08-14 09:24:30 -04:00
|
|
|
|
TotalRecordCount = internalResult.TotalRecordCount
|
2013-11-25 15:39:23 -05:00
|
|
|
|
};
|
2013-12-14 20:17:57 -05:00
|
|
|
|
|
2014-03-09 18:14:44 -04:00
|
|
|
|
return result;
|
2013-11-24 15:51:45 -05:00
|
|
|
|
}
|
|
|
|
|
|
2013-12-19 16:51:32 -05:00
|
|
|
|
public LiveTvChannel GetInternalChannel(string id)
|
2013-11-24 15:51:45 -05:00
|
|
|
|
{
|
2013-12-28 11:58:13 -05:00
|
|
|
|
return GetInternalChannel(new Guid(id));
|
|
|
|
|
}
|
2013-11-24 16:30:38 -05:00
|
|
|
|
|
2013-12-28 11:58:13 -05:00
|
|
|
|
private LiveTvChannel GetInternalChannel(Guid id)
|
|
|
|
|
{
|
2014-01-11 00:49:18 -05:00
|
|
|
|
return _libraryManager.GetItemById(id) as LiveTvChannel;
|
2013-12-22 12:16:24 -05:00
|
|
|
|
}
|
|
|
|
|
|
2015-05-31 15:12:58 -04:00
|
|
|
|
internal LiveTvProgram GetInternalProgram(string id)
|
2013-12-22 12:16:24 -05:00
|
|
|
|
{
|
2015-06-01 10:49:23 -04:00
|
|
|
|
return _libraryManager.GetItemById(id) as LiveTvProgram;
|
2014-03-09 18:14:44 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
internal LiveTvProgram GetInternalProgram(Guid id)
|
2014-03-09 18:14:44 -04:00
|
|
|
|
{
|
2015-06-01 10:49:23 -04:00
|
|
|
|
return _libraryManager.GetItemById(id) as LiveTvProgram;
|
2014-03-09 18:14:44 -04:00
|
|
|
|
}
|
|
|
|
|
|
2014-01-01 13:26:31 -05:00
|
|
|
|
public async Task<ILiveTvRecording> GetInternalRecording(string id, CancellationToken cancellationToken)
|
2013-12-19 16:51:32 -05:00
|
|
|
|
{
|
2016-02-14 12:58:31 -05:00
|
|
|
|
if (string.IsNullOrWhiteSpace(id))
|
|
|
|
|
{
|
|
|
|
|
throw new ArgumentNullException("id");
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-12 11:51:48 -04:00
|
|
|
|
var result = await GetInternalRecordings(new RecordingQuery
|
|
|
|
|
{
|
|
|
|
|
Id = id
|
2013-12-19 16:51:32 -05:00
|
|
|
|
|
2015-03-12 11:51:48 -04:00
|
|
|
|
}, cancellationToken).ConfigureAwait(false);
|
2013-12-19 16:51:32 -05:00
|
|
|
|
|
2015-03-12 11:51:48 -04:00
|
|
|
|
return result.Items.FirstOrDefault() as ILiveTvRecording;
|
2013-12-19 16:51:32 -05:00
|
|
|
|
}
|
2013-12-21 13:37:34 -05:00
|
|
|
|
|
2014-01-17 11:36:01 -05:00
|
|
|
|
private readonly SemaphoreSlim _liveStreamSemaphore = new SemaphoreSlim(1, 1);
|
|
|
|
|
|
2015-03-20 01:40:51 -04:00
|
|
|
|
public async Task<MediaSourceInfo> GetRecordingStream(string id, CancellationToken cancellationToken)
|
2014-07-02 14:34:08 -04:00
|
|
|
|
{
|
2015-05-15 22:36:47 -04:00
|
|
|
|
return await GetLiveStream(id, null, false, cancellationToken).ConfigureAwait(false);
|
2014-07-02 14:34:08 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-05-15 22:36:47 -04:00
|
|
|
|
public async Task<MediaSourceInfo> GetChannelStream(string id, string mediaSourceId, CancellationToken cancellationToken)
|
2014-07-02 14:34:08 -04:00
|
|
|
|
{
|
2015-05-15 22:36:47 -04:00
|
|
|
|
return await GetLiveStream(id, mediaSourceId, true, cancellationToken).ConfigureAwait(false);
|
2014-07-02 14:34:08 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-03-29 00:56:39 -04:00
|
|
|
|
public async Task<IEnumerable<MediaSourceInfo>> GetRecordingMediaSources(string id, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var item = await GetInternalRecording(id, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
var service = GetService(item);
|
|
|
|
|
|
|
|
|
|
return await service.GetRecordingStreamMediaSources(id, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task<IEnumerable<MediaSourceInfo>> GetChannelMediaSources(string id, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var item = GetInternalChannel(id);
|
|
|
|
|
var service = GetService(item);
|
|
|
|
|
|
2015-05-18 12:40:20 -04:00
|
|
|
|
var sources = await service.GetChannelStreamMediaSources(item.ExternalId, cancellationToken).ConfigureAwait(false);
|
2015-09-01 15:18:25 -04:00
|
|
|
|
|
|
|
|
|
if (sources.Count == 0)
|
|
|
|
|
{
|
|
|
|
|
throw new NotImplementedException();
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-18 12:40:20 -04:00
|
|
|
|
var list = sources.ToList();
|
|
|
|
|
|
|
|
|
|
foreach (var source in list)
|
|
|
|
|
{
|
2016-02-27 12:41:28 -05:00
|
|
|
|
Normalize(source, service, item.ChannelType == ChannelType.TV);
|
2015-05-18 12:40:20 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return list;
|
2015-03-29 00:56:39 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-03-12 11:51:48 -04:00
|
|
|
|
private ILiveTvService GetService(ILiveTvItem item)
|
|
|
|
|
{
|
|
|
|
|
return GetService(item.ServiceName);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private ILiveTvService GetService(string name)
|
|
|
|
|
{
|
|
|
|
|
return _services.FirstOrDefault(i => string.Equals(i.Name, name, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-15 22:36:47 -04:00
|
|
|
|
private async Task<MediaSourceInfo> GetLiveStream(string id, string mediaSourceId, bool isChannel, CancellationToken cancellationToken)
|
2013-12-22 13:58:51 -05:00
|
|
|
|
{
|
2014-01-17 11:36:01 -05:00
|
|
|
|
await _liveStreamSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
|
2013-12-22 13:58:51 -05:00
|
|
|
|
|
2015-09-01 18:04:54 -04:00
|
|
|
|
if (string.Equals(id, mediaSourceId, StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
{
|
|
|
|
|
mediaSourceId = null;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-17 11:36:01 -05:00
|
|
|
|
try
|
|
|
|
|
{
|
2015-03-20 01:40:51 -04:00
|
|
|
|
MediaSourceInfo info;
|
2015-03-29 00:56:39 -04:00
|
|
|
|
bool isVideo;
|
2016-02-27 12:41:28 -05:00
|
|
|
|
ILiveTvService service;
|
2014-01-17 11:36:01 -05:00
|
|
|
|
|
2014-07-02 14:34:08 -04:00
|
|
|
|
if (isChannel)
|
|
|
|
|
{
|
|
|
|
|
var channel = GetInternalChannel(id);
|
2015-03-27 16:55:31 -04:00
|
|
|
|
isVideo = channel.ChannelType == ChannelType.TV;
|
2016-02-27 12:41:28 -05:00
|
|
|
|
service = GetService(channel);
|
2014-07-02 14:34:08 -04:00
|
|
|
|
_logger.Info("Opening channel stream from {0}, external channel Id: {1}", service.Name, channel.ExternalId);
|
2015-05-15 22:36:47 -04:00
|
|
|
|
info = await service.GetChannelStream(channel.ExternalId, mediaSourceId, cancellationToken).ConfigureAwait(false);
|
2015-03-28 16:22:27 -04:00
|
|
|
|
info.RequiresClosing = true;
|
2015-03-29 14:16:40 -04:00
|
|
|
|
|
2015-08-02 15:08:55 -04:00
|
|
|
|
if (info.RequiresClosing)
|
2015-03-29 14:16:40 -04:00
|
|
|
|
{
|
2015-03-29 23:04:55 -04:00
|
|
|
|
var idPrefix = service.GetType().FullName.GetMD5().ToString("N") + "_";
|
|
|
|
|
|
|
|
|
|
info.LiveStreamId = idPrefix + info.Id;
|
2015-03-29 14:16:40 -04:00
|
|
|
|
}
|
2014-07-02 14:34:08 -04:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
2015-03-12 11:51:48 -04:00
|
|
|
|
var recording = await GetInternalRecording(id, cancellationToken).ConfigureAwait(false);
|
2015-03-27 16:55:31 -04:00
|
|
|
|
isVideo = !string.Equals(recording.MediaType, MediaType.Audio, StringComparison.OrdinalIgnoreCase);
|
2016-02-27 12:41:28 -05:00
|
|
|
|
service = GetService(recording);
|
2014-01-12 01:31:21 -05:00
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
_logger.Info("Opening recording stream from {0}, external recording Id: {1}", service.Name, recording.ExternalId);
|
|
|
|
|
info = await service.GetRecordingStream(recording.ExternalId, null, cancellationToken).ConfigureAwait(false);
|
2015-03-28 16:22:27 -04:00
|
|
|
|
info.RequiresClosing = true;
|
2015-03-29 14:16:40 -04:00
|
|
|
|
|
2015-08-02 15:08:55 -04:00
|
|
|
|
if (info.RequiresClosing)
|
2015-03-29 14:16:40 -04:00
|
|
|
|
{
|
2015-03-29 23:04:55 -04:00
|
|
|
|
var idPrefix = service.GetType().FullName.GetMD5().ToString("N") + "_";
|
|
|
|
|
|
|
|
|
|
info.LiveStreamId = idPrefix + info.Id;
|
2015-03-29 14:16:40 -04:00
|
|
|
|
}
|
2014-07-02 14:34:08 -04:00
|
|
|
|
}
|
2014-06-02 15:32:41 -04:00
|
|
|
|
|
2014-08-15 12:35:41 -04:00
|
|
|
|
_logger.Info("Live stream info: {0}", _jsonSerializer.SerializeToString(info));
|
2016-02-27 12:41:28 -05:00
|
|
|
|
Normalize(info, service, isVideo);
|
2014-05-27 17:17:48 -04:00
|
|
|
|
|
2014-07-02 14:34:08 -04:00
|
|
|
|
var data = new LiveStreamData
|
2014-01-17 11:36:01 -05:00
|
|
|
|
{
|
2014-07-02 14:34:08 -04:00
|
|
|
|
Info = info,
|
|
|
|
|
IsChannel = isChannel,
|
|
|
|
|
ItemId = id
|
|
|
|
|
};
|
2014-01-17 11:36:01 -05:00
|
|
|
|
|
2014-07-02 14:34:08 -04:00
|
|
|
|
_openStreams.AddOrUpdate(info.Id, data, (key, i) => data);
|
|
|
|
|
|
|
|
|
|
return info;
|
2014-01-17 11:36:01 -05:00
|
|
|
|
}
|
2014-01-18 23:25:01 -05:00
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting channel stream", ex);
|
|
|
|
|
|
|
|
|
|
throw;
|
|
|
|
|
}
|
2014-01-17 11:36:01 -05:00
|
|
|
|
finally
|
2014-01-12 01:31:21 -05:00
|
|
|
|
{
|
2014-01-17 11:36:01 -05:00
|
|
|
|
_liveStreamSemaphore.Release();
|
2014-01-12 01:31:21 -05:00
|
|
|
|
}
|
2013-12-29 13:53:56 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-02-27 12:41:28 -05:00
|
|
|
|
private void Normalize(MediaSourceInfo mediaSource, ILiveTvService service, bool isVideo)
|
2014-06-02 15:32:41 -04:00
|
|
|
|
{
|
2015-03-20 01:40:51 -04:00
|
|
|
|
if (mediaSource.MediaStreams.Count == 0)
|
2014-10-15 00:11:40 -04:00
|
|
|
|
{
|
2015-03-27 16:55:31 -04:00
|
|
|
|
if (isVideo)
|
2015-03-20 01:40:51 -04:00
|
|
|
|
{
|
2015-03-27 16:55:31 -04:00
|
|
|
|
mediaSource.MediaStreams.AddRange(new List<MediaStream>
|
2015-03-20 01:40:51 -04:00
|
|
|
|
{
|
2015-03-27 16:55:31 -04:00
|
|
|
|
new MediaStream
|
|
|
|
|
{
|
|
|
|
|
Type = MediaStreamType.Video,
|
|
|
|
|
// Set the index to -1 because we don't know the exact index of the video stream within the container
|
2015-03-29 00:56:39 -04:00
|
|
|
|
Index = -1,
|
|
|
|
|
|
|
|
|
|
// Set to true if unknown to enable deinterlacing
|
|
|
|
|
IsInterlaced = true
|
2015-03-27 16:55:31 -04:00
|
|
|
|
},
|
|
|
|
|
new MediaStream
|
|
|
|
|
{
|
|
|
|
|
Type = MediaStreamType.Audio,
|
|
|
|
|
// Set the index to -1 because we don't know the exact index of the audio stream within the container
|
|
|
|
|
Index = -1
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
mediaSource.MediaStreams.AddRange(new List<MediaStream>
|
2015-03-20 01:40:51 -04:00
|
|
|
|
{
|
2015-03-27 16:55:31 -04:00
|
|
|
|
new MediaStream
|
|
|
|
|
{
|
|
|
|
|
Type = MediaStreamType.Audio,
|
|
|
|
|
// Set the index to -1 because we don't know the exact index of the audio stream within the container
|
|
|
|
|
Index = -1
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
}
|
2014-10-15 00:11:40 -04:00
|
|
|
|
}
|
2015-03-20 01:40:51 -04:00
|
|
|
|
|
|
|
|
|
// Clean some bad data coming from providers
|
|
|
|
|
foreach (var stream in mediaSource.MediaStreams)
|
2014-10-15 00:11:40 -04:00
|
|
|
|
{
|
2015-03-20 01:40:51 -04:00
|
|
|
|
if (stream.BitRate.HasValue && stream.BitRate <= 0)
|
|
|
|
|
{
|
|
|
|
|
stream.BitRate = null;
|
|
|
|
|
}
|
|
|
|
|
if (stream.Channels.HasValue && stream.Channels <= 0)
|
|
|
|
|
{
|
|
|
|
|
stream.Channels = null;
|
|
|
|
|
}
|
|
|
|
|
if (stream.AverageFrameRate.HasValue && stream.AverageFrameRate <= 0)
|
|
|
|
|
{
|
|
|
|
|
stream.AverageFrameRate = null;
|
|
|
|
|
}
|
|
|
|
|
if (stream.RealFrameRate.HasValue && stream.RealFrameRate <= 0)
|
|
|
|
|
{
|
|
|
|
|
stream.RealFrameRate = null;
|
|
|
|
|
}
|
|
|
|
|
if (stream.Width.HasValue && stream.Width <= 0)
|
|
|
|
|
{
|
|
|
|
|
stream.Width = null;
|
|
|
|
|
}
|
|
|
|
|
if (stream.Height.HasValue && stream.Height <= 0)
|
|
|
|
|
{
|
|
|
|
|
stream.Height = null;
|
|
|
|
|
}
|
|
|
|
|
if (stream.SampleRate.HasValue && stream.SampleRate <= 0)
|
|
|
|
|
{
|
|
|
|
|
stream.SampleRate = null;
|
|
|
|
|
}
|
|
|
|
|
if (stream.Level.HasValue && stream.Level <= 0)
|
|
|
|
|
{
|
|
|
|
|
stream.Level = null;
|
|
|
|
|
}
|
2014-10-15 00:11:40 -04:00
|
|
|
|
}
|
2015-03-20 01:40:51 -04:00
|
|
|
|
|
|
|
|
|
var indexes = mediaSource.MediaStreams.Select(i => i.Index).Distinct().ToList();
|
|
|
|
|
|
|
|
|
|
// If there are duplicate stream indexes, set them all to unknown
|
|
|
|
|
if (indexes.Count != mediaSource.MediaStreams.Count)
|
2014-10-15 00:11:40 -04:00
|
|
|
|
{
|
2015-03-20 01:40:51 -04:00
|
|
|
|
foreach (var stream in mediaSource.MediaStreams)
|
|
|
|
|
{
|
|
|
|
|
stream.Index = -1;
|
|
|
|
|
}
|
2014-06-02 15:32:41 -04:00
|
|
|
|
}
|
2015-05-15 22:36:47 -04:00
|
|
|
|
|
|
|
|
|
// Set the total bitrate if not already supplied
|
|
|
|
|
if (!mediaSource.Bitrate.HasValue)
|
|
|
|
|
{
|
|
|
|
|
var total = mediaSource.MediaStreams.Select(i => i.BitRate ?? 0).Sum();
|
|
|
|
|
|
|
|
|
|
if (total > 0)
|
|
|
|
|
{
|
|
|
|
|
mediaSource.Bitrate = total;
|
|
|
|
|
}
|
|
|
|
|
}
|
2016-02-27 12:41:28 -05:00
|
|
|
|
|
|
|
|
|
if (!(service is EmbyTV.EmbyTV))
|
|
|
|
|
{
|
|
|
|
|
// We can't trust that we'll be able to direct stream it through emby server, no matter what the provider says
|
|
|
|
|
mediaSource.SupportsDirectStream = true;
|
|
|
|
|
}
|
2014-06-02 15:32:41 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
private async Task<LiveTvChannel> GetChannel(ChannelInfo channelInfo, string serviceName, Guid parentFolderId, CancellationToken cancellationToken)
|
2013-11-24 15:51:45 -05:00
|
|
|
|
{
|
|
|
|
|
var isNew = false;
|
|
|
|
|
|
2013-12-22 22:46:03 -05:00
|
|
|
|
var id = _tvDtoService.GetInternalChannelId(serviceName, channelInfo.Id);
|
2013-11-24 15:51:45 -05:00
|
|
|
|
|
2013-12-19 16:51:32 -05:00
|
|
|
|
var item = _itemRepo.RetrieveItem(id) as LiveTvChannel;
|
2013-11-24 15:51:45 -05:00
|
|
|
|
|
2015-01-17 13:15:09 -05:00
|
|
|
|
if (item == null)
|
2013-11-24 15:51:45 -05:00
|
|
|
|
{
|
2013-12-19 16:51:32 -05:00
|
|
|
|
item = new LiveTvChannel
|
2013-11-24 15:51:45 -05:00
|
|
|
|
{
|
|
|
|
|
Name = channelInfo.Name,
|
|
|
|
|
Id = id,
|
2015-01-17 13:15:09 -05:00
|
|
|
|
DateCreated = DateTime.UtcNow,
|
2013-11-24 15:51:45 -05:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
isNew = true;
|
|
|
|
|
}
|
|
|
|
|
|
2015-10-05 22:50:20 -04:00
|
|
|
|
if (!string.Equals(channelInfo.Id, item.ExternalId))
|
|
|
|
|
{
|
|
|
|
|
isNew = true;
|
|
|
|
|
}
|
2014-01-23 13:05:41 -05:00
|
|
|
|
item.ExternalId = channelInfo.Id;
|
2015-10-05 22:50:20 -04:00
|
|
|
|
|
2015-11-23 11:04:57 -05:00
|
|
|
|
if (!item.ParentId.Equals(parentFolderId))
|
|
|
|
|
{
|
|
|
|
|
isNew = true;
|
|
|
|
|
}
|
|
|
|
|
item.ParentId = parentFolderId;
|
|
|
|
|
|
2015-10-05 22:50:20 -04:00
|
|
|
|
item.ChannelType = channelInfo.ChannelType;
|
2013-12-19 16:51:32 -05:00
|
|
|
|
item.ServiceName = serviceName;
|
2014-01-23 13:05:41 -05:00
|
|
|
|
item.Number = channelInfo.Number;
|
|
|
|
|
|
2015-07-24 11:20:11 -04:00
|
|
|
|
//if (!string.Equals(item.ProviderImageUrl, channelInfo.ImageUrl, StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
//{
|
|
|
|
|
// isNew = true;
|
|
|
|
|
// replaceImages.Add(ImageType.Primary);
|
|
|
|
|
//}
|
|
|
|
|
//if (!string.Equals(item.ProviderImagePath, channelInfo.ImagePath, StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
//{
|
|
|
|
|
// isNew = true;
|
|
|
|
|
// replaceImages.Add(ImageType.Primary);
|
|
|
|
|
//}
|
2014-08-25 22:30:52 -04:00
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
if (!item.HasImage(ImageType.Primary))
|
2015-11-20 23:54:41 -05:00
|
|
|
|
{
|
2015-11-21 00:01:16 -05:00
|
|
|
|
if (!string.IsNullOrWhiteSpace(channelInfo.ImagePath))
|
|
|
|
|
{
|
|
|
|
|
item.SetImagePath(ImageType.Primary, channelInfo.ImagePath);
|
|
|
|
|
}
|
|
|
|
|
else if (!string.IsNullOrWhiteSpace(channelInfo.ImageUrl))
|
|
|
|
|
{
|
|
|
|
|
item.SetImagePath(ImageType.Primary, channelInfo.ImageUrl);
|
|
|
|
|
}
|
2015-10-25 13:13:30 -04:00
|
|
|
|
}
|
2015-02-10 14:47:54 -05:00
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
if (string.IsNullOrEmpty(item.Name))
|
|
|
|
|
{
|
|
|
|
|
item.Name = channelInfo.Name;
|
|
|
|
|
}
|
2013-12-19 16:51:32 -05:00
|
|
|
|
|
2015-09-21 12:26:05 -04:00
|
|
|
|
await item.RefreshMetadata(new MetadataRefreshOptions(_fileSystem)
|
2014-01-28 13:37:01 -05:00
|
|
|
|
{
|
2015-11-21 00:01:16 -05:00
|
|
|
|
ForceSave = isNew
|
2014-01-28 13:37:01 -05:00
|
|
|
|
|
|
|
|
|
}, cancellationToken);
|
2013-11-24 15:51:45 -05:00
|
|
|
|
|
|
|
|
|
return item;
|
|
|
|
|
}
|
2013-11-25 11:15:31 -05:00
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
private async Task<LiveTvProgram> GetProgram(ProgramInfo info, LiveTvChannel channel, ChannelType channelType, string serviceName, CancellationToken cancellationToken)
|
2013-12-21 13:37:34 -05:00
|
|
|
|
{
|
|
|
|
|
var id = _tvDtoService.GetInternalProgramId(serviceName, info.Id);
|
|
|
|
|
|
2015-03-15 21:48:25 -04:00
|
|
|
|
var item = _libraryManager.GetItemById(id) as LiveTvProgram;
|
2015-06-01 10:49:23 -04:00
|
|
|
|
var isNew = false;
|
2015-11-21 00:01:16 -05:00
|
|
|
|
var forceUpdate = false;
|
2013-12-21 13:37:34 -05:00
|
|
|
|
|
|
|
|
|
if (item == null)
|
|
|
|
|
{
|
2015-06-01 10:49:23 -04:00
|
|
|
|
isNew = true;
|
2013-12-21 13:37:34 -05:00
|
|
|
|
item = new LiveTvProgram
|
|
|
|
|
{
|
|
|
|
|
Name = info.Name,
|
|
|
|
|
Id = id,
|
|
|
|
|
DateCreated = DateTime.UtcNow,
|
2015-08-21 22:59:10 -04:00
|
|
|
|
DateModified = DateTime.UtcNow,
|
2015-10-04 14:10:50 -04:00
|
|
|
|
ExternalEtag = info.Etag
|
2013-12-21 13:37:34 -05:00
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-23 11:04:57 -05:00
|
|
|
|
if (!item.ParentId.Equals(channel.Id))
|
|
|
|
|
{
|
|
|
|
|
forceUpdate = true;
|
|
|
|
|
}
|
|
|
|
|
item.ParentId = channel.Id;
|
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
//item.ChannelType = channelType;
|
|
|
|
|
if (!string.Equals(item.ServiceName, serviceName, StringComparison.Ordinal))
|
|
|
|
|
{
|
|
|
|
|
forceUpdate = true;
|
|
|
|
|
}
|
2013-12-21 13:37:34 -05:00
|
|
|
|
item.ServiceName = serviceName;
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
item.Audio = info.Audio;
|
2015-11-21 00:01:16 -05:00
|
|
|
|
item.ChannelId = channel.Id.ToString("N");
|
2015-06-01 10:49:23 -04:00
|
|
|
|
item.CommunityRating = item.CommunityRating ?? info.CommunityRating;
|
2014-01-23 13:05:41 -05:00
|
|
|
|
item.EndDate = info.EndDate;
|
|
|
|
|
item.EpisodeTitle = info.EpisodeTitle;
|
|
|
|
|
item.ExternalId = info.Id;
|
|
|
|
|
item.Genres = info.Genres;
|
|
|
|
|
item.IsHD = info.IsHD;
|
|
|
|
|
item.IsKids = info.IsKids;
|
|
|
|
|
item.IsLive = info.IsLive;
|
|
|
|
|
item.IsMovie = info.IsMovie;
|
|
|
|
|
item.IsNews = info.IsNews;
|
|
|
|
|
item.IsPremiere = info.IsPremiere;
|
|
|
|
|
item.IsRepeat = info.IsRepeat;
|
|
|
|
|
item.IsSeries = info.IsSeries;
|
|
|
|
|
item.IsSports = info.IsSports;
|
|
|
|
|
item.Name = info.Name;
|
2015-06-01 10:49:23 -04:00
|
|
|
|
item.OfficialRating = item.OfficialRating ?? info.OfficialRating;
|
|
|
|
|
item.Overview = item.Overview ?? info.Overview;
|
2014-01-23 13:05:41 -05:00
|
|
|
|
item.RunTimeTicks = (info.EndDate - info.StartDate).Ticks;
|
|
|
|
|
item.StartDate = info.StartDate;
|
2015-08-11 13:47:29 -04:00
|
|
|
|
item.HomePageUrl = info.HomePageUrl;
|
2014-01-23 13:05:41 -05:00
|
|
|
|
|
2015-03-31 14:50:08 -04:00
|
|
|
|
item.ProductionYear = info.ProductionYear;
|
2015-09-29 12:29:06 -04:00
|
|
|
|
item.PremiereDate = info.OriginalAirDate;
|
2015-04-15 23:23:13 -04:00
|
|
|
|
|
2015-08-19 02:12:58 -04:00
|
|
|
|
item.IndexNumber = info.EpisodeNumber;
|
|
|
|
|
item.ParentIndexNumber = info.SeasonNumber;
|
|
|
|
|
|
2015-11-02 14:29:40 -05:00
|
|
|
|
if (!item.HasImage(ImageType.Primary))
|
2015-10-25 13:13:30 -04:00
|
|
|
|
{
|
2015-11-02 14:29:40 -05:00
|
|
|
|
if (!string.IsNullOrWhiteSpace(info.ImagePath))
|
|
|
|
|
{
|
2015-11-20 19:27:34 -05:00
|
|
|
|
item.SetImage(new ItemImageInfo
|
|
|
|
|
{
|
|
|
|
|
Path = info.ImagePath,
|
|
|
|
|
Type = ImageType.Primary,
|
|
|
|
|
IsPlaceholder = true
|
|
|
|
|
}, 0);
|
2015-11-02 14:29:40 -05:00
|
|
|
|
}
|
|
|
|
|
else if (!string.IsNullOrWhiteSpace(info.ImageUrl))
|
|
|
|
|
{
|
2015-11-20 19:27:34 -05:00
|
|
|
|
item.SetImage(new ItemImageInfo
|
|
|
|
|
{
|
|
|
|
|
Path = info.ImageUrl,
|
|
|
|
|
Type = ImageType.Primary,
|
|
|
|
|
IsPlaceholder = true
|
|
|
|
|
}, 0);
|
2015-11-02 14:29:40 -05:00
|
|
|
|
}
|
2015-10-25 13:13:30 -04:00
|
|
|
|
}
|
2015-11-21 00:01:16 -05:00
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
if (isNew)
|
|
|
|
|
{
|
|
|
|
|
await _libraryManager.CreateItem(item, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
}
|
2015-11-21 00:01:16 -05:00
|
|
|
|
else if (forceUpdate || string.IsNullOrWhiteSpace(info.Etag))
|
2015-09-21 12:26:05 -04:00
|
|
|
|
{
|
|
|
|
|
await _libraryManager.UpdateItem(item, ItemUpdateType.MetadataImport, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
}
|
2015-06-01 10:49:23 -04:00
|
|
|
|
else
|
|
|
|
|
{
|
2015-09-21 12:26:05 -04:00
|
|
|
|
// Increment this whenver some internal change deems it necessary
|
2015-10-04 14:10:50 -04:00
|
|
|
|
var etag = info.Etag + "4";
|
2015-09-21 12:26:05 -04:00
|
|
|
|
|
2015-10-04 14:10:50 -04:00
|
|
|
|
if (!string.Equals(etag, item.ExternalEtag, StringComparison.OrdinalIgnoreCase))
|
2015-08-21 22:59:10 -04:00
|
|
|
|
{
|
2015-10-04 14:10:50 -04:00
|
|
|
|
item.ExternalEtag = etag;
|
2015-08-21 22:59:10 -04:00
|
|
|
|
await _libraryManager.UpdateItem(item, ItemUpdateType.MetadataImport, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
}
|
2015-06-01 10:49:23 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-09-21 12:26:05 -04:00
|
|
|
|
_providerManager.QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem));
|
2015-03-15 21:48:25 -04:00
|
|
|
|
|
2013-12-21 13:37:34 -05:00
|
|
|
|
return item;
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
private async Task<Guid> CreateRecordingRecord(RecordingInfo info, string serviceName, Guid parentFolderId, CancellationToken cancellationToken)
|
2013-12-19 16:51:32 -05:00
|
|
|
|
{
|
|
|
|
|
var isNew = false;
|
|
|
|
|
|
|
|
|
|
var id = _tvDtoService.GetInternalRecordingId(serviceName, info.Id);
|
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
var item = _itemRepo.RetrieveItem(id);
|
2013-12-19 16:51:32 -05:00
|
|
|
|
|
|
|
|
|
if (item == null)
|
|
|
|
|
{
|
2014-06-01 00:11:04 -04:00
|
|
|
|
if (info.ChannelType == ChannelType.TV)
|
2013-12-19 16:51:32 -05:00
|
|
|
|
{
|
2014-01-01 13:26:31 -05:00
|
|
|
|
item = new LiveTvVideoRecording
|
|
|
|
|
{
|
|
|
|
|
Name = info.Name,
|
|
|
|
|
Id = id,
|
|
|
|
|
DateCreated = DateTime.UtcNow,
|
|
|
|
|
DateModified = DateTime.UtcNow,
|
|
|
|
|
VideoType = VideoType.VideoFile
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
item = new LiveTvAudioRecording
|
|
|
|
|
{
|
|
|
|
|
Name = info.Name,
|
|
|
|
|
Id = id,
|
|
|
|
|
DateCreated = DateTime.UtcNow,
|
|
|
|
|
DateModified = DateTime.UtcNow
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-19 16:51:32 -05:00
|
|
|
|
isNew = true;
|
|
|
|
|
}
|
2015-10-16 18:36:01 -04:00
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
item.ChannelId = _tvDtoService.GetInternalChannelId(serviceName, info.ChannelId).ToString("N");
|
2015-05-31 14:22:51 -04:00
|
|
|
|
item.CommunityRating = info.CommunityRating;
|
|
|
|
|
item.OfficialRating = info.OfficialRating;
|
|
|
|
|
item.Overview = info.Overview;
|
|
|
|
|
item.EndDate = info.EndDate;
|
2015-06-01 13:07:55 -04:00
|
|
|
|
item.Genres = info.Genres;
|
2015-09-29 12:29:06 -04:00
|
|
|
|
item.PremiereDate = info.OriginalAirDate;
|
2015-05-31 14:22:51 -04:00
|
|
|
|
|
|
|
|
|
var recording = (ILiveTvRecording)item;
|
|
|
|
|
|
2015-06-04 16:27:46 -04:00
|
|
|
|
recording.ExternalId = info.Id;
|
|
|
|
|
|
2015-10-29 18:45:07 -04:00
|
|
|
|
var dataChanged = false;
|
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
recording.Audio = info.Audio;
|
|
|
|
|
recording.EndDate = info.EndDate;
|
|
|
|
|
recording.EpisodeTitle = info.EpisodeTitle;
|
|
|
|
|
recording.IsHD = info.IsHD;
|
|
|
|
|
recording.IsKids = info.IsKids;
|
|
|
|
|
recording.IsLive = info.IsLive;
|
|
|
|
|
recording.IsMovie = info.IsMovie;
|
|
|
|
|
recording.IsNews = info.IsNews;
|
|
|
|
|
recording.IsPremiere = info.IsPremiere;
|
|
|
|
|
recording.IsRepeat = info.IsRepeat;
|
|
|
|
|
recording.IsSports = info.IsSports;
|
|
|
|
|
recording.SeriesTimerId = info.SeriesTimerId;
|
|
|
|
|
recording.StartDate = info.StartDate;
|
2015-10-11 12:12:53 -04:00
|
|
|
|
|
2015-10-29 18:45:07 -04:00
|
|
|
|
if (!dataChanged)
|
|
|
|
|
{
|
|
|
|
|
dataChanged = recording.IsSeries != info.IsSeries;
|
|
|
|
|
}
|
|
|
|
|
recording.IsSeries = info.IsSeries;
|
|
|
|
|
|
2015-11-23 11:04:57 -05:00
|
|
|
|
if (!item.ParentId.Equals(parentFolderId))
|
|
|
|
|
{
|
|
|
|
|
dataChanged = true;
|
|
|
|
|
}
|
|
|
|
|
item.ParentId = parentFolderId;
|
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
if (!item.HasImage(ImageType.Primary))
|
2015-10-25 13:13:30 -04:00
|
|
|
|
{
|
2015-11-21 00:01:16 -05:00
|
|
|
|
if (!string.IsNullOrWhiteSpace(info.ImagePath))
|
|
|
|
|
{
|
2016-02-21 12:22:31 -05:00
|
|
|
|
item.SetImage(new ItemImageInfo
|
|
|
|
|
{
|
|
|
|
|
Path = info.ImagePath,
|
|
|
|
|
Type = ImageType.Primary,
|
|
|
|
|
IsPlaceholder = true
|
|
|
|
|
}, 0);
|
2015-11-21 00:01:16 -05:00
|
|
|
|
}
|
|
|
|
|
else if (!string.IsNullOrWhiteSpace(info.ImageUrl))
|
|
|
|
|
{
|
2016-02-21 12:22:31 -05:00
|
|
|
|
item.SetImage(new ItemImageInfo
|
|
|
|
|
{
|
|
|
|
|
Path = info.ImageUrl,
|
|
|
|
|
Type = ImageType.Primary,
|
|
|
|
|
IsPlaceholder = true
|
|
|
|
|
}, 0);
|
2015-11-21 00:01:16 -05:00
|
|
|
|
}
|
2015-10-25 13:13:30 -04:00
|
|
|
|
}
|
2015-10-29 18:45:07 -04:00
|
|
|
|
|
2015-10-11 12:12:53 -04:00
|
|
|
|
var statusChanged = info.Status != recording.Status;
|
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
recording.Status = info.Status;
|
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
recording.ServiceName = serviceName;
|
2013-12-19 16:51:32 -05:00
|
|
|
|
|
2014-08-05 21:09:03 -04:00
|
|
|
|
if (!string.IsNullOrEmpty(info.Path))
|
|
|
|
|
{
|
2015-10-29 18:45:07 -04:00
|
|
|
|
if (!dataChanged)
|
|
|
|
|
{
|
|
|
|
|
dataChanged = !string.Equals(item.Path, info.Path);
|
|
|
|
|
}
|
2015-10-03 23:38:46 -04:00
|
|
|
|
var fileInfo = _fileSystem.GetFileInfo(info.Path);
|
2015-08-18 11:25:57 -04:00
|
|
|
|
|
|
|
|
|
recording.DateCreated = _fileSystem.GetCreationTimeUtc(fileInfo);
|
|
|
|
|
recording.DateModified = _fileSystem.GetLastWriteTimeUtc(fileInfo);
|
2015-10-16 18:36:01 -04:00
|
|
|
|
item.Path = info.Path;
|
2014-08-05 21:09:03 -04:00
|
|
|
|
}
|
|
|
|
|
else if (!string.IsNullOrEmpty(info.Url))
|
|
|
|
|
{
|
2015-10-29 18:45:07 -04:00
|
|
|
|
if (!dataChanged)
|
|
|
|
|
{
|
|
|
|
|
dataChanged = !string.Equals(item.Path, info.Url);
|
|
|
|
|
}
|
2014-08-05 21:09:03 -04:00
|
|
|
|
item.Path = info.Url;
|
|
|
|
|
}
|
|
|
|
|
|
2015-10-16 18:36:01 -04:00
|
|
|
|
var metadataRefreshMode = MetadataRefreshMode.Default;
|
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
if (isNew)
|
2014-01-28 13:37:01 -05:00
|
|
|
|
{
|
2015-06-01 13:07:55 -04:00
|
|
|
|
await _libraryManager.CreateItem(item, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
}
|
2015-10-29 18:45:07 -04:00
|
|
|
|
else if (dataChanged || info.DateLastUpdated > recording.DateLastSaved || statusChanged)
|
2015-06-01 13:07:55 -04:00
|
|
|
|
{
|
2015-10-16 18:36:01 -04:00
|
|
|
|
metadataRefreshMode = MetadataRefreshMode.FullRefresh;
|
2015-06-01 13:07:55 -04:00
|
|
|
|
await _libraryManager.UpdateItem(item, ItemUpdateType.MetadataImport, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
}
|
2013-12-19 16:51:32 -05:00
|
|
|
|
|
2016-03-06 23:56:45 -05:00
|
|
|
|
if (info.Status != RecordingStatus.InProgress)
|
2015-10-16 18:36:01 -04:00
|
|
|
|
{
|
2016-03-06 23:56:45 -05:00
|
|
|
|
_providerManager.QueueRefresh(item.Id, new MetadataRefreshOptions(_fileSystem)
|
|
|
|
|
{
|
|
|
|
|
MetadataRefreshMode = metadataRefreshMode
|
|
|
|
|
});
|
|
|
|
|
}
|
2014-01-11 00:49:18 -05:00
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
return item.Id;
|
2013-12-19 16:51:32 -05:00
|
|
|
|
}
|
|
|
|
|
|
2015-05-31 15:12:58 -04:00
|
|
|
|
public async Task<BaseItemDto> GetProgram(string id, CancellationToken cancellationToken, User user = null)
|
2013-12-17 15:02:12 -05:00
|
|
|
|
{
|
2015-03-14 16:00:32 -04:00
|
|
|
|
var program = GetInternalProgram(id);
|
2013-12-21 13:37:34 -05:00
|
|
|
|
|
2015-05-31 15:12:58 -04:00
|
|
|
|
var dto = _dtoService.GetBaseItemDto(program, new DtoOptions(), user);
|
2013-12-21 13:37:34 -05:00
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
var list = new List<Tuple<BaseItemDto, string, string>>();
|
|
|
|
|
list.Add(new Tuple<BaseItemDto, string, string>(dto, program.ServiceName, program.ExternalId));
|
|
|
|
|
|
|
|
|
|
await AddRecordingInfo(list, cancellationToken).ConfigureAwait(false);
|
2013-12-17 15:02:12 -05:00
|
|
|
|
|
2013-12-21 13:37:34 -05:00
|
|
|
|
return dto;
|
2013-12-17 15:02:12 -05:00
|
|
|
|
}
|
|
|
|
|
|
2015-08-02 13:02:23 -04:00
|
|
|
|
public async Task<QueryResult<BaseItemDto>> GetPrograms(ProgramQuery query, DtoOptions options, CancellationToken cancellationToken)
|
2013-11-25 11:15:31 -05:00
|
|
|
|
{
|
2015-11-21 00:01:16 -05:00
|
|
|
|
var user = string.IsNullOrEmpty(query.UserId) ? null : _userManager.GetUserById(query.UserId);
|
|
|
|
|
|
2015-11-23 11:04:57 -05:00
|
|
|
|
var internalQuery = new InternalItemsQuery(user)
|
2014-01-05 20:59:21 -05:00
|
|
|
|
{
|
2015-06-01 10:49:23 -04:00
|
|
|
|
IncludeItemTypes = new[] { typeof(LiveTvProgram).Name },
|
|
|
|
|
MinEndDate = query.MinEndDate,
|
|
|
|
|
MinStartDate = query.MinStartDate,
|
|
|
|
|
MaxEndDate = query.MaxEndDate,
|
|
|
|
|
MaxStartDate = query.MaxStartDate,
|
|
|
|
|
ChannelIds = query.ChannelIds,
|
|
|
|
|
IsMovie = query.IsMovie,
|
2015-07-28 08:33:30 -04:00
|
|
|
|
IsSports = query.IsSports,
|
2015-08-04 10:26:36 -04:00
|
|
|
|
IsKids = query.IsKids,
|
2015-08-24 23:13:04 -04:00
|
|
|
|
Genres = query.Genres,
|
|
|
|
|
StartIndex = query.StartIndex,
|
|
|
|
|
Limit = query.Limit,
|
|
|
|
|
SortBy = query.SortBy,
|
|
|
|
|
SortOrder = query.SortOrder ?? SortOrder.Ascending
|
2015-06-01 10:49:23 -04:00
|
|
|
|
};
|
2014-01-05 20:59:21 -05:00
|
|
|
|
|
2015-03-06 22:53:31 -05:00
|
|
|
|
if (query.HasAired.HasValue)
|
|
|
|
|
{
|
2015-06-01 10:49:23 -04:00
|
|
|
|
if (query.HasAired.Value)
|
2013-12-21 13:37:34 -05:00
|
|
|
|
{
|
2015-06-01 10:49:23 -04:00
|
|
|
|
internalQuery.MaxEndDate = DateTime.UtcNow;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
internalQuery.MinEndDate = DateTime.UtcNow;
|
|
|
|
|
}
|
2013-11-25 15:39:23 -05:00
|
|
|
|
}
|
|
|
|
|
|
2015-08-24 23:13:04 -04:00
|
|
|
|
var queryResult = _libraryManager.QueryItems(internalQuery);
|
2013-12-21 13:37:34 -05:00
|
|
|
|
|
2015-08-24 23:13:04 -04:00
|
|
|
|
var returnArray = queryResult.Items
|
2015-11-21 00:01:16 -05:00
|
|
|
|
.Cast<LiveTvProgram>()
|
|
|
|
|
.Select(i => new Tuple<BaseItemDto, string, string>(_dtoService.GetBaseItemDto(i, options, user), i.ServiceName, i.ExternalId))
|
2013-12-21 13:37:34 -05:00
|
|
|
|
.ToArray();
|
|
|
|
|
|
|
|
|
|
await AddRecordingInfo(returnArray, cancellationToken).ConfigureAwait(false);
|
2013-11-25 15:39:23 -05:00
|
|
|
|
|
2015-05-31 15:12:58 -04:00
|
|
|
|
var result = new QueryResult<BaseItemDto>
|
2013-11-26 16:36:11 -05:00
|
|
|
|
{
|
2015-11-21 00:01:16 -05:00
|
|
|
|
Items = returnArray.Select(i => i.Item1).ToArray(),
|
2015-08-24 23:13:04 -04:00
|
|
|
|
TotalRecordCount = queryResult.TotalRecordCount
|
2013-11-26 16:36:11 -05:00
|
|
|
|
};
|
2013-12-17 15:02:12 -05:00
|
|
|
|
|
2013-12-21 13:37:34 -05:00
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2014-09-01 16:10:54 -04:00
|
|
|
|
public async Task<QueryResult<LiveTvProgram>> GetRecommendedProgramsInternal(RecommendedProgramQuery query, CancellationToken cancellationToken)
|
2014-01-12 10:58:47 -05:00
|
|
|
|
{
|
2015-11-21 00:01:16 -05:00
|
|
|
|
var user = _userManager.GetUserById(query.UserId);
|
|
|
|
|
|
2015-11-23 11:04:57 -05:00
|
|
|
|
var internalQuery = new InternalItemsQuery(user)
|
2014-01-12 10:58:47 -05:00
|
|
|
|
{
|
2015-06-01 10:49:23 -04:00
|
|
|
|
IncludeItemTypes = new[] { typeof(LiveTvProgram).Name },
|
|
|
|
|
IsAiring = query.IsAiring,
|
|
|
|
|
IsMovie = query.IsMovie,
|
2015-08-04 10:26:36 -04:00
|
|
|
|
IsSports = query.IsSports,
|
|
|
|
|
IsKids = query.IsKids
|
2015-06-01 10:49:23 -04:00
|
|
|
|
};
|
2014-01-12 10:58:47 -05:00
|
|
|
|
|
|
|
|
|
if (query.HasAired.HasValue)
|
|
|
|
|
{
|
2015-06-01 10:49:23 -04:00
|
|
|
|
if (query.HasAired.Value)
|
|
|
|
|
{
|
|
|
|
|
internalQuery.MaxEndDate = DateTime.UtcNow;
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
internalQuery.MinEndDate = DateTime.UtcNow;
|
|
|
|
|
}
|
2014-01-12 10:58:47 -05:00
|
|
|
|
}
|
|
|
|
|
|
2015-08-19 19:57:27 -04:00
|
|
|
|
IEnumerable<LiveTvProgram> programs = _libraryManager.QueryItems(internalQuery).Items.Cast<LiveTvProgram>();
|
2015-04-03 12:31:56 -04:00
|
|
|
|
|
2014-01-12 10:58:47 -05:00
|
|
|
|
var programList = programs.ToList();
|
|
|
|
|
|
|
|
|
|
var genres = programList.SelectMany(i => i.Genres)
|
2015-08-12 17:39:02 -04:00
|
|
|
|
.Where(i => !string.IsNullOrWhiteSpace(i))
|
2015-04-09 17:11:57 -04:00
|
|
|
|
.DistinctNames()
|
2014-01-12 10:58:47 -05:00
|
|
|
|
.Select(i => _libraryManager.GetGenre(i))
|
2015-08-12 17:39:02 -04:00
|
|
|
|
.DistinctBy(i => i.Id)
|
2014-01-12 10:58:47 -05:00
|
|
|
|
.ToDictionary(i => i.Name, StringComparer.OrdinalIgnoreCase);
|
|
|
|
|
|
2014-03-07 13:48:55 -05:00
|
|
|
|
programs = programList.OrderBy(i => i.HasImage(ImageType.Primary) ? 0 : 1)
|
2015-03-19 12:16:33 -04:00
|
|
|
|
.ThenByDescending(i => GetRecommendationScore(i, user.Id, genres))
|
2014-01-23 13:05:41 -05:00
|
|
|
|
.ThenBy(i => i.StartDate);
|
2014-01-12 10:58:47 -05:00
|
|
|
|
|
|
|
|
|
if (query.Limit.HasValue)
|
|
|
|
|
{
|
2015-08-23 22:08:20 -04:00
|
|
|
|
programs = programs.Take(query.Limit.Value);
|
2014-01-12 10:58:47 -05:00
|
|
|
|
}
|
|
|
|
|
|
2014-03-09 18:14:44 -04:00
|
|
|
|
programList = programs.ToList();
|
|
|
|
|
|
2014-09-01 16:10:54 -04:00
|
|
|
|
var returnArray = programList.ToArray();
|
|
|
|
|
|
|
|
|
|
var result = new QueryResult<LiveTvProgram>
|
|
|
|
|
{
|
|
|
|
|
Items = returnArray,
|
|
|
|
|
TotalRecordCount = returnArray.Length
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-02 13:02:23 -04:00
|
|
|
|
public async Task<QueryResult<BaseItemDto>> GetRecommendedPrograms(RecommendedProgramQuery query, DtoOptions options, CancellationToken cancellationToken)
|
2014-09-01 16:10:54 -04:00
|
|
|
|
{
|
|
|
|
|
var internalResult = await GetRecommendedProgramsInternal(query, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
2014-09-14 11:10:51 -04:00
|
|
|
|
var user = _userManager.GetUserById(query.UserId);
|
2014-09-01 16:10:54 -04:00
|
|
|
|
|
|
|
|
|
var returnArray = internalResult.Items
|
2015-11-21 00:01:16 -05:00
|
|
|
|
.Select(i => new Tuple<BaseItemDto, string, string>(_dtoService.GetBaseItemDto(i, options, user), i.ServiceName, i.ExternalId))
|
2014-01-12 10:58:47 -05:00
|
|
|
|
.ToArray();
|
|
|
|
|
|
|
|
|
|
await AddRecordingInfo(returnArray, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
2015-05-31 15:12:58 -04:00
|
|
|
|
var result = new QueryResult<BaseItemDto>
|
2014-01-12 10:58:47 -05:00
|
|
|
|
{
|
2015-11-21 00:01:16 -05:00
|
|
|
|
Items = returnArray.Select(i => i.Item1).ToArray(),
|
2014-09-01 16:10:54 -04:00
|
|
|
|
TotalRecordCount = internalResult.TotalRecordCount
|
2014-01-12 10:58:47 -05:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-19 12:16:33 -04:00
|
|
|
|
private int GetRecommendationScore(LiveTvProgram program, Guid userId, Dictionary<string, Genre> genres)
|
2014-01-12 10:58:47 -05:00
|
|
|
|
{
|
|
|
|
|
var score = 0;
|
|
|
|
|
|
|
|
|
|
if (program.IsLive)
|
|
|
|
|
{
|
|
|
|
|
score++;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (program.IsSeries && !program.IsRepeat)
|
|
|
|
|
{
|
|
|
|
|
score++;
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
var channel = GetInternalChannel(program.ChannelId);
|
2014-01-12 10:58:47 -05:00
|
|
|
|
|
|
|
|
|
var channelUserdata = _userDataManager.GetUserData(userId, channel.GetUserDataKey());
|
|
|
|
|
|
|
|
|
|
if ((channelUserdata.Likes ?? false))
|
|
|
|
|
{
|
|
|
|
|
score += 2;
|
|
|
|
|
}
|
|
|
|
|
else if (!(channelUserdata.Likes ?? true))
|
|
|
|
|
{
|
|
|
|
|
score -= 2;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (channelUserdata.IsFavorite)
|
|
|
|
|
{
|
|
|
|
|
score += 3;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
score += GetGenreScore(program.Genres, userId, genres);
|
|
|
|
|
|
|
|
|
|
return score;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private int GetGenreScore(IEnumerable<string> programGenres, Guid userId, Dictionary<string, Genre> genres)
|
|
|
|
|
{
|
|
|
|
|
return programGenres.Select(i =>
|
|
|
|
|
{
|
|
|
|
|
var score = 0;
|
|
|
|
|
|
|
|
|
|
Genre genre;
|
|
|
|
|
|
|
|
|
|
if (genres.TryGetValue(i, out genre))
|
|
|
|
|
{
|
|
|
|
|
var genreUserdata = _userDataManager.GetUserData(userId, genre.GetUserDataKey());
|
|
|
|
|
|
|
|
|
|
if ((genreUserdata.Likes ?? false))
|
|
|
|
|
{
|
|
|
|
|
score++;
|
|
|
|
|
}
|
|
|
|
|
else if (!(genreUserdata.Likes ?? true))
|
|
|
|
|
{
|
|
|
|
|
score--;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (genreUserdata.IsFavorite)
|
|
|
|
|
{
|
|
|
|
|
score += 2;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return score;
|
|
|
|
|
|
|
|
|
|
}).Sum();
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
private async Task AddRecordingInfo(IEnumerable<Tuple<BaseItemDto, string, string>> programs, CancellationToken cancellationToken)
|
2013-12-21 13:37:34 -05:00
|
|
|
|
{
|
2015-03-19 12:16:33 -04:00
|
|
|
|
var timers = new Dictionary<string, List<TimerInfo>>();
|
2013-12-21 13:37:34 -05:00
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
foreach (var programTuple in programs)
|
2013-12-21 13:37:34 -05:00
|
|
|
|
{
|
2015-11-21 00:01:16 -05:00
|
|
|
|
var program = programTuple.Item1;
|
|
|
|
|
var serviceName = programTuple.Item2;
|
|
|
|
|
var externalProgramId = programTuple.Item3;
|
|
|
|
|
|
|
|
|
|
if (string.IsNullOrWhiteSpace(serviceName))
|
|
|
|
|
{
|
|
|
|
|
continue;
|
|
|
|
|
}
|
2015-10-28 15:40:38 -04:00
|
|
|
|
|
2015-03-19 12:16:33 -04:00
|
|
|
|
List<TimerInfo> timerList;
|
2015-11-21 00:01:16 -05:00
|
|
|
|
if (!timers.TryGetValue(serviceName, out timerList))
|
2015-03-19 12:16:33 -04:00
|
|
|
|
{
|
2015-04-17 00:53:47 -04:00
|
|
|
|
try
|
|
|
|
|
{
|
2015-11-21 00:01:16 -05:00
|
|
|
|
var tempTimers = await GetService(serviceName).GetTimersAsync(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
timers[serviceName] = timerList = tempTimers.ToList();
|
2015-04-17 00:53:47 -04:00
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting timer infos", ex);
|
2015-11-21 00:01:16 -05:00
|
|
|
|
timers[serviceName] = timerList = new List<TimerInfo>();
|
2015-04-17 00:53:47 -04:00
|
|
|
|
}
|
2015-03-19 12:16:33 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
var timer = timerList.FirstOrDefault(i => string.Equals(i.ProgramId, externalProgramId, StringComparison.OrdinalIgnoreCase));
|
2013-12-21 13:37:34 -05:00
|
|
|
|
|
|
|
|
|
if (timer != null)
|
|
|
|
|
{
|
2015-11-21 00:01:16 -05:00
|
|
|
|
program.TimerId = _tvDtoService.GetInternalTimerId(serviceName, timer.Id)
|
2013-12-21 13:37:34 -05:00
|
|
|
|
.ToString("N");
|
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(timer.SeriesTimerId))
|
|
|
|
|
{
|
2015-11-21 00:01:16 -05:00
|
|
|
|
program.SeriesTimerId = _tvDtoService.GetInternalSeriesTimerId(serviceName, timer.SeriesTimerId)
|
2013-12-21 13:37:34 -05:00
|
|
|
|
.ToString("N");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2013-11-25 16:53:06 -05:00
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
internal Task RefreshChannels(IProgress<double> progress, CancellationToken cancellationToken)
|
2014-02-27 11:25:04 -05:00
|
|
|
|
{
|
2015-06-01 10:49:23 -04:00
|
|
|
|
return RefreshChannelsInternal(progress, cancellationToken);
|
2014-02-27 11:25:04 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private async Task RefreshChannelsInternal(IProgress<double> progress, CancellationToken cancellationToken)
|
2013-11-25 16:53:06 -05:00
|
|
|
|
{
|
2015-03-19 12:16:33 -04:00
|
|
|
|
var numComplete = 0;
|
|
|
|
|
double progressPerService = _services.Count == 0
|
|
|
|
|
? 0
|
|
|
|
|
: 1 / _services.Count;
|
2013-11-25 16:53:06 -05:00
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
var newChannelIdList = new List<Guid>();
|
|
|
|
|
var newProgramIdList = new List<Guid>();
|
|
|
|
|
|
2015-03-19 12:16:33 -04:00
|
|
|
|
foreach (var service in _services)
|
2013-12-05 11:50:21 -05:00
|
|
|
|
{
|
2015-03-19 12:16:33 -04:00
|
|
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
|
|
|
|
2015-08-31 00:57:12 -04:00
|
|
|
|
_logger.Debug("Refreshing guide from {0}", service.Name);
|
|
|
|
|
|
2015-03-19 12:16:33 -04:00
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
var innerProgress = new ActionableProgress<double>();
|
|
|
|
|
innerProgress.RegisterAction(p => progress.Report(p * progressPerService));
|
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
var idList = await RefreshChannelsInternal(service, innerProgress, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
newChannelIdList.AddRange(idList.Item1);
|
|
|
|
|
newProgramIdList.AddRange(idList.Item2);
|
2015-03-19 12:16:33 -04:00
|
|
|
|
}
|
|
|
|
|
catch (OperationCanceledException)
|
|
|
|
|
{
|
|
|
|
|
throw;
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error refreshing channels for service", ex);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
numComplete++;
|
|
|
|
|
double percent = numComplete;
|
|
|
|
|
percent /= _services.Count;
|
|
|
|
|
|
|
|
|
|
progress.Report(100 * percent);
|
2013-12-05 11:50:21 -05:00
|
|
|
|
}
|
2013-11-25 16:53:06 -05:00
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
await CleanDatabaseInternal(newChannelIdList, new[] { typeof(LiveTvChannel).Name }, progress, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
await CleanDatabaseInternal(newProgramIdList, new[] { typeof(LiveTvProgram).Name }, progress, cancellationToken).ConfigureAwait(false);
|
2015-06-01 10:49:23 -04:00
|
|
|
|
|
2015-09-17 21:51:22 -04:00
|
|
|
|
var coreService = _services.OfType<EmbyTV.EmbyTV>().FirstOrDefault();
|
|
|
|
|
|
|
|
|
|
if (coreService != null)
|
|
|
|
|
{
|
|
|
|
|
await coreService.RefreshSeriesTimers(cancellationToken, new Progress<double>()).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
// Load these now which will prefetch metadata
|
|
|
|
|
var dtoOptions = new DtoOptions();
|
|
|
|
|
dtoOptions.Fields.Remove(ItemFields.SyncInfo);
|
|
|
|
|
await GetRecordings(new RecordingQuery(), dtoOptions, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
2015-03-19 12:16:33 -04:00
|
|
|
|
progress.Report(100);
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
private async Task<Tuple<List<Guid>, List<Guid>>> RefreshChannelsInternal(ILiveTvService service, IProgress<double> progress, CancellationToken cancellationToken)
|
2015-03-19 12:16:33 -04:00
|
|
|
|
{
|
2013-11-25 16:53:06 -05:00
|
|
|
|
progress.Report(10);
|
|
|
|
|
|
2013-12-05 11:50:21 -05:00
|
|
|
|
var allChannels = await GetChannels(service, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
var allChannelsList = allChannels.ToList();
|
2013-11-25 16:53:06 -05:00
|
|
|
|
|
2013-12-19 16:51:32 -05:00
|
|
|
|
var list = new List<LiveTvChannel>();
|
2013-11-25 16:53:06 -05:00
|
|
|
|
|
|
|
|
|
var numComplete = 0;
|
2015-11-21 00:01:16 -05:00
|
|
|
|
var parentFolder = await GetInternalLiveTvFolder(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
var parentFolderId = parentFolder.Id;
|
2013-11-25 16:53:06 -05:00
|
|
|
|
|
2013-12-05 11:50:21 -05:00
|
|
|
|
foreach (var channelInfo in allChannelsList)
|
2013-11-25 16:53:06 -05:00
|
|
|
|
{
|
2014-02-09 16:11:11 -05:00
|
|
|
|
cancellationToken.ThrowIfCancellationRequested();
|
2014-02-19 23:53:15 -05:00
|
|
|
|
|
2013-11-25 16:53:06 -05:00
|
|
|
|
try
|
|
|
|
|
{
|
2015-11-21 00:01:16 -05:00
|
|
|
|
var item = await GetChannel(channelInfo.Item2, channelInfo.Item1, parentFolderId, cancellationToken).ConfigureAwait(false);
|
2013-11-25 16:53:06 -05:00
|
|
|
|
|
2014-01-02 23:58:22 -05:00
|
|
|
|
list.Add(item);
|
2014-01-11 00:49:18 -05:00
|
|
|
|
|
|
|
|
|
_libraryManager.RegisterItem(item);
|
2014-01-02 23:58:22 -05:00
|
|
|
|
}
|
|
|
|
|
catch (OperationCanceledException)
|
|
|
|
|
{
|
|
|
|
|
throw;
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting channel information for {0}", ex, channelInfo.Item2.Name);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
numComplete++;
|
|
|
|
|
double percent = numComplete;
|
|
|
|
|
percent /= allChannelsList.Count;
|
|
|
|
|
|
|
|
|
|
progress.Report(5 * percent + 10);
|
|
|
|
|
}
|
2014-01-11 00:49:18 -05:00
|
|
|
|
|
2014-01-02 23:58:22 -05:00
|
|
|
|
progress.Report(15);
|
|
|
|
|
|
2014-01-11 18:07:56 -05:00
|
|
|
|
numComplete = 0;
|
2015-06-01 10:49:23 -04:00
|
|
|
|
var programs = new List<Guid>();
|
|
|
|
|
var channels = new List<Guid>();
|
2014-01-02 23:58:22 -05:00
|
|
|
|
|
2014-01-12 11:55:38 -05:00
|
|
|
|
var guideDays = GetGuideDays(list.Count);
|
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
_logger.Info("Refreshing guide with {0} days of guide data", guideDays);
|
|
|
|
|
|
2014-02-09 16:11:11 -05:00
|
|
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
foreach (var currentChannel in list)
|
2014-01-02 23:58:22 -05:00
|
|
|
|
{
|
2015-06-01 10:49:23 -04:00
|
|
|
|
channels.Add(currentChannel.Id);
|
2014-02-09 16:11:11 -05:00
|
|
|
|
cancellationToken.ThrowIfCancellationRequested();
|
2014-02-19 23:53:15 -05:00
|
|
|
|
|
2014-01-02 23:58:22 -05:00
|
|
|
|
try
|
|
|
|
|
{
|
2014-01-12 11:55:38 -05:00
|
|
|
|
var start = DateTime.UtcNow.AddHours(-1);
|
|
|
|
|
var end = start.AddDays(guideDays);
|
2014-01-12 10:58:47 -05:00
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
var channelPrograms = await service.GetProgramsAsync(currentChannel.ExternalId, start, end, cancellationToken).ConfigureAwait(false);
|
2013-11-25 16:53:06 -05:00
|
|
|
|
|
2015-03-15 21:48:25 -04:00
|
|
|
|
foreach (var program in channelPrograms)
|
|
|
|
|
{
|
2015-11-21 00:01:16 -05:00
|
|
|
|
var programItem = await GetProgram(program, currentChannel, currentChannel.ChannelType, service.Name, cancellationToken).ConfigureAwait(false);
|
2015-09-21 12:26:05 -04:00
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
programs.Add(programItem.Id);
|
2015-03-15 21:48:25 -04:00
|
|
|
|
}
|
2013-11-25 16:53:06 -05:00
|
|
|
|
}
|
|
|
|
|
catch (OperationCanceledException)
|
|
|
|
|
{
|
|
|
|
|
throw;
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
2014-01-02 23:58:22 -05:00
|
|
|
|
_logger.ErrorException("Error getting programs for channel {0}", ex, currentChannel.Name);
|
2013-11-25 16:53:06 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
numComplete++;
|
|
|
|
|
double percent = numComplete;
|
2013-12-05 11:50:21 -05:00
|
|
|
|
percent /= allChannelsList.Count;
|
2013-11-25 16:53:06 -05:00
|
|
|
|
|
2014-02-27 11:25:04 -05:00
|
|
|
|
progress.Report(80 * percent + 10);
|
2013-11-25 16:53:06 -05:00
|
|
|
|
}
|
2014-02-27 11:25:04 -05:00
|
|
|
|
progress.Report(100);
|
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
return new Tuple<List<Guid>, List<Guid>>(channels, programs);
|
2015-02-10 14:47:54 -05:00
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
private async Task CleanDatabaseInternal(List<Guid> currentIdList, string[] validTypes, IProgress<double> progress, CancellationToken cancellationToken)
|
2014-02-19 23:53:15 -05:00
|
|
|
|
{
|
2015-06-01 10:49:23 -04:00
|
|
|
|
var list = _itemRepo.GetItemIds(new InternalItemsQuery
|
|
|
|
|
{
|
2015-06-01 13:07:55 -04:00
|
|
|
|
IncludeItemTypes = validTypes
|
2015-06-01 10:49:23 -04:00
|
|
|
|
|
|
|
|
|
}).Items.ToList();
|
2014-02-19 23:53:15 -05:00
|
|
|
|
|
|
|
|
|
var numComplete = 0;
|
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
foreach (var itemId in list)
|
2014-02-19 23:53:15 -05:00
|
|
|
|
{
|
|
|
|
|
cancellationToken.ThrowIfCancellationRequested();
|
|
|
|
|
|
2015-10-18 13:35:36 -04:00
|
|
|
|
if (itemId == Guid.Empty)
|
|
|
|
|
{
|
|
|
|
|
// Somehow some invalid data got into the db. It probably predates the boundary checking
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
if (!currentIdList.Contains(itemId))
|
2014-02-19 23:53:15 -05:00
|
|
|
|
{
|
2015-06-01 10:49:23 -04:00
|
|
|
|
var item = _libraryManager.GetItemById(itemId);
|
2015-03-21 12:10:02 -04:00
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
if (item != null)
|
2015-03-21 12:10:02 -04:00
|
|
|
|
{
|
2015-06-02 01:46:06 -04:00
|
|
|
|
await _libraryManager.DeleteItem(item, new DeleteOptions
|
|
|
|
|
{
|
|
|
|
|
DeleteFileLocation = false
|
|
|
|
|
|
|
|
|
|
}).ConfigureAwait(false);
|
2015-03-21 12:10:02 -04:00
|
|
|
|
}
|
2014-02-19 23:53:15 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
numComplete++;
|
|
|
|
|
double percent = numComplete;
|
|
|
|
|
percent /= list.Count;
|
|
|
|
|
|
2014-02-27 11:25:04 -05:00
|
|
|
|
progress.Report(100 * percent);
|
2014-02-19 23:53:15 -05:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
private const int MaxGuideDays = 14;
|
2014-01-12 11:55:38 -05:00
|
|
|
|
private double GetGuideDays(int channelCount)
|
|
|
|
|
{
|
2014-07-27 18:01:29 -04:00
|
|
|
|
var config = GetConfiguration();
|
|
|
|
|
|
|
|
|
|
if (config.GuideDays.HasValue)
|
2014-01-12 11:55:38 -05:00
|
|
|
|
{
|
2015-11-21 00:01:16 -05:00
|
|
|
|
return Math.Max(1, Math.Min(config.GuideDays.Value, MaxGuideDays));
|
2014-01-12 11:55:38 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var programsPerDay = channelCount * 48;
|
|
|
|
|
|
2014-01-16 22:13:12 -05:00
|
|
|
|
const int maxPrograms = 24000;
|
2014-01-12 11:55:38 -05:00
|
|
|
|
|
|
|
|
|
var days = Math.Round(((double)maxPrograms) / programsPerDay);
|
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
return Math.Max(3, Math.Min(days, MaxGuideDays));
|
2014-01-12 11:55:38 -05:00
|
|
|
|
}
|
|
|
|
|
|
2013-11-26 16:36:11 -05:00
|
|
|
|
private async Task<IEnumerable<Tuple<string, ChannelInfo>>> GetChannels(ILiveTvService service, CancellationToken cancellationToken)
|
2013-11-25 16:53:06 -05:00
|
|
|
|
{
|
2013-11-26 16:36:11 -05:00
|
|
|
|
var channels = await service.GetChannelsAsync(cancellationToken).ConfigureAwait(false);
|
2013-11-25 16:53:06 -05:00
|
|
|
|
|
2013-11-26 16:36:11 -05:00
|
|
|
|
return channels.Select(i => new Tuple<string, ChannelInfo>(service.Name, i));
|
2013-11-25 16:53:06 -05:00
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
private DateTime _lastRecordingRefreshTime;
|
|
|
|
|
private async Task RefreshRecordings(CancellationToken cancellationToken)
|
2013-11-25 21:53:48 -05:00
|
|
|
|
{
|
2015-06-01 13:07:55 -04:00
|
|
|
|
const int cacheMinutes = 5;
|
|
|
|
|
|
|
|
|
|
if ((DateTime.UtcNow - _lastRecordingRefreshTime).TotalMinutes < cacheMinutes)
|
2014-06-23 12:05:19 -04:00
|
|
|
|
{
|
2015-06-01 13:07:55 -04:00
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
await _refreshRecordingsLock.WaitAsync(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
if ((DateTime.UtcNow - _lastRecordingRefreshTime).TotalMinutes < cacheMinutes)
|
2014-06-23 12:05:19 -04:00
|
|
|
|
{
|
2015-06-01 13:07:55 -04:00
|
|
|
|
return;
|
2015-03-19 12:29:31 -04:00
|
|
|
|
}
|
2015-06-01 13:07:55 -04:00
|
|
|
|
|
|
|
|
|
var tasks = _services.Select(async i =>
|
2015-03-19 12:29:31 -04:00
|
|
|
|
{
|
2015-06-01 13:07:55 -04:00
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
var recs = await i.GetRecordingsAsync(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
return recs.Select(r => new Tuple<RecordingInfo, ILiveTvService>(r, i));
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting recordings", ex);
|
|
|
|
|
return new List<Tuple<RecordingInfo, ILiveTvService>>();
|
|
|
|
|
}
|
|
|
|
|
});
|
2014-06-23 12:05:19 -04:00
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
var results = await Task.WhenAll(tasks).ConfigureAwait(false);
|
2015-11-21 00:01:16 -05:00
|
|
|
|
var folder = await GetInternalLiveTvFolder(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
var parentFolderId = folder.Id;
|
2015-06-01 13:07:55 -04:00
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
var recordingTasks = results.SelectMany(i => i.ToList()).Select(i => CreateRecordingRecord(i.Item1, i.Item2.Name, parentFolderId, cancellationToken));
|
2015-06-01 13:07:55 -04:00
|
|
|
|
|
|
|
|
|
var idList = await Task.WhenAll(recordingTasks).ConfigureAwait(false);
|
|
|
|
|
|
2015-10-10 20:39:30 -04:00
|
|
|
|
await CleanDatabaseInternal(idList.ToList(), new[] { typeof(LiveTvVideoRecording).Name, typeof(LiveTvAudioRecording).Name }, new Progress<double>(), cancellationToken).ConfigureAwait(false);
|
2013-11-26 16:36:11 -05:00
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
_lastRecordingRefreshTime = DateTime.UtcNow;
|
|
|
|
|
}
|
|
|
|
|
finally
|
|
|
|
|
{
|
|
|
|
|
_refreshRecordingsLock.Release();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task<QueryResult<BaseItem>> GetInternalRecordings(RecordingQuery query, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var user = string.IsNullOrEmpty(query.UserId) ? null : _userManager.GetUserById(query.UserId);
|
2014-06-23 12:05:19 -04:00
|
|
|
|
if (user != null && !IsLiveTvEnabled(user))
|
|
|
|
|
{
|
2015-06-01 13:07:55 -04:00
|
|
|
|
return new QueryResult<BaseItem>();
|
2014-06-23 12:05:19 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
await RefreshRecordings(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
2015-11-23 11:04:57 -05:00
|
|
|
|
var internalQuery = new InternalItemsQuery(user)
|
2013-12-19 16:51:32 -05:00
|
|
|
|
{
|
2015-06-01 13:07:55 -04:00
|
|
|
|
IncludeItemTypes = new[] { typeof(LiveTvVideoRecording).Name, typeof(LiveTvAudioRecording).Name }
|
|
|
|
|
};
|
2013-12-28 16:37:01 -05:00
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
if (!string.IsNullOrEmpty(query.ChannelId))
|
|
|
|
|
{
|
|
|
|
|
internalQuery.ChannelIds = new[] { query.ChannelId };
|
2013-11-26 16:36:11 -05:00
|
|
|
|
}
|
|
|
|
|
|
2015-11-23 11:04:57 -05:00
|
|
|
|
var queryResult = _libraryManager.GetItems(internalQuery, new string[] { });
|
|
|
|
|
IEnumerable<ILiveTvRecording> recordings = queryResult.Cast<ILiveTvRecording>();
|
2015-06-01 13:07:55 -04:00
|
|
|
|
|
2016-02-14 12:58:31 -05:00
|
|
|
|
if (!string.IsNullOrWhiteSpace(query.Id))
|
2013-11-26 16:36:11 -05:00
|
|
|
|
{
|
2013-12-28 16:37:01 -05:00
|
|
|
|
var guid = new Guid(query.Id);
|
|
|
|
|
|
2014-01-01 13:26:31 -05:00
|
|
|
|
recordings = recordings
|
2015-06-01 13:07:55 -04:00
|
|
|
|
.Where(i => i.Id == guid);
|
2013-12-28 16:37:01 -05:00
|
|
|
|
}
|
|
|
|
|
|
2016-02-14 12:58:31 -05:00
|
|
|
|
if (!string.IsNullOrWhiteSpace(query.GroupId))
|
2013-12-28 16:37:01 -05:00
|
|
|
|
{
|
|
|
|
|
var guid = new Guid(query.GroupId);
|
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
recordings = recordings.Where(i => GetRecordingGroupIds(i).Contains(guid));
|
2014-01-01 13:26:31 -05:00
|
|
|
|
}
|
|
|
|
|
|
2014-01-15 10:18:31 -05:00
|
|
|
|
if (query.IsInProgress.HasValue)
|
2014-01-01 13:26:31 -05:00
|
|
|
|
{
|
2014-01-15 10:18:31 -05:00
|
|
|
|
var val = query.IsInProgress.Value;
|
2015-06-01 13:07:55 -04:00
|
|
|
|
recordings = recordings.Where(i => (i.Status == RecordingStatus.InProgress) == val);
|
2013-11-26 16:36:11 -05:00
|
|
|
|
}
|
|
|
|
|
|
2014-01-15 10:18:31 -05:00
|
|
|
|
if (query.Status.HasValue)
|
|
|
|
|
{
|
|
|
|
|
var val = query.Status.Value;
|
2015-06-01 13:07:55 -04:00
|
|
|
|
recordings = recordings.Where(i => (i.Status == val));
|
2014-01-15 10:18:31 -05:00
|
|
|
|
}
|
|
|
|
|
|
2014-01-08 00:25:21 -05:00
|
|
|
|
if (!string.IsNullOrEmpty(query.SeriesTimerId))
|
|
|
|
|
{
|
|
|
|
|
var guid = new Guid(query.SeriesTimerId);
|
|
|
|
|
|
|
|
|
|
recordings = recordings
|
2015-06-01 13:07:55 -04:00
|
|
|
|
.Where(i => _tvDtoService.GetInternalSeriesTimerId(i.ServiceName, i.SeriesTimerId) == guid);
|
2014-01-08 00:25:21 -05:00
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
recordings = recordings.OrderByDescending(i => i.StartDate);
|
|
|
|
|
|
|
|
|
|
var entityList = recordings.ToList();
|
|
|
|
|
IEnumerable<ILiveTvRecording> entities = entityList;
|
2014-03-13 05:00:47 -04:00
|
|
|
|
|
2013-12-28 18:09:24 -05:00
|
|
|
|
if (query.StartIndex.HasValue)
|
|
|
|
|
{
|
|
|
|
|
entities = entities.Skip(query.StartIndex.Value);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (query.Limit.HasValue)
|
|
|
|
|
{
|
|
|
|
|
entities = entities.Take(query.Limit.Value);
|
2013-12-21 13:37:34 -05:00
|
|
|
|
}
|
|
|
|
|
|
2014-08-14 09:24:30 -04:00
|
|
|
|
return new QueryResult<BaseItem>
|
|
|
|
|
{
|
|
|
|
|
Items = entities.Cast<BaseItem>().ToArray(),
|
|
|
|
|
TotalRecordCount = entityList.Count
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2016-03-02 13:42:39 -05:00
|
|
|
|
public async Task AddInfoToProgramDto(List<Tuple<BaseItem, BaseItemDto>> tuples, List<ItemFields> fields, User user = null)
|
2015-05-31 15:12:58 -04:00
|
|
|
|
{
|
2016-03-02 13:42:39 -05:00
|
|
|
|
var recordingTuples = new List<Tuple<BaseItemDto, string, string>>();
|
2015-05-31 15:12:58 -04:00
|
|
|
|
|
2016-03-02 13:42:39 -05:00
|
|
|
|
foreach (var tuple in tuples)
|
2015-08-05 21:21:18 -04:00
|
|
|
|
{
|
2016-03-02 13:42:39 -05:00
|
|
|
|
var program = (LiveTvProgram)tuple.Item1;
|
|
|
|
|
var dto = tuple.Item2;
|
2015-08-05 21:21:18 -04:00
|
|
|
|
|
2016-03-02 13:42:39 -05:00
|
|
|
|
dto.StartDate = program.StartDate;
|
|
|
|
|
dto.EpisodeTitle = program.EpisodeTitle;
|
2015-05-31 15:12:58 -04:00
|
|
|
|
|
2016-03-02 13:42:39 -05:00
|
|
|
|
if (program.IsRepeat)
|
|
|
|
|
{
|
|
|
|
|
dto.IsRepeat = program.IsRepeat;
|
|
|
|
|
}
|
|
|
|
|
if (program.IsMovie)
|
|
|
|
|
{
|
|
|
|
|
dto.IsMovie = program.IsMovie;
|
|
|
|
|
}
|
|
|
|
|
if (program.IsSeries)
|
2015-05-31 15:12:58 -04:00
|
|
|
|
{
|
2016-03-02 13:42:39 -05:00
|
|
|
|
dto.IsSeries = program.IsSeries;
|
|
|
|
|
}
|
|
|
|
|
if (program.IsSports)
|
|
|
|
|
{
|
|
|
|
|
dto.IsSports = program.IsSports;
|
|
|
|
|
}
|
|
|
|
|
if (program.IsLive)
|
|
|
|
|
{
|
|
|
|
|
dto.IsLive = program.IsLive;
|
|
|
|
|
}
|
|
|
|
|
if (program.IsNews)
|
|
|
|
|
{
|
|
|
|
|
dto.IsNews = program.IsNews;
|
|
|
|
|
}
|
|
|
|
|
if (program.IsKids)
|
|
|
|
|
{
|
|
|
|
|
dto.IsKids = program.IsKids;
|
|
|
|
|
}
|
|
|
|
|
if (program.IsPremiere)
|
|
|
|
|
{
|
|
|
|
|
dto.IsPremiere = program.IsPremiere;
|
|
|
|
|
}
|
2015-10-11 12:12:53 -04:00
|
|
|
|
|
2016-03-02 13:42:39 -05:00
|
|
|
|
if (fields.Contains(ItemFields.ChannelInfo))
|
|
|
|
|
{
|
|
|
|
|
var channel = GetInternalChannel(program.ChannelId);
|
|
|
|
|
|
|
|
|
|
if (channel != null)
|
2015-10-11 12:12:53 -04:00
|
|
|
|
{
|
2016-03-02 13:42:39 -05:00
|
|
|
|
dto.ChannelName = channel.Name;
|
|
|
|
|
dto.MediaType = channel.MediaType;
|
|
|
|
|
|
|
|
|
|
if (channel.HasImage(ImageType.Primary))
|
|
|
|
|
{
|
|
|
|
|
dto.ChannelPrimaryImageTag = _tvDtoService.GetImageTag(channel);
|
|
|
|
|
}
|
2015-10-11 12:12:53 -04:00
|
|
|
|
}
|
2015-05-31 15:12:58 -04:00
|
|
|
|
}
|
2016-02-12 13:29:28 -05:00
|
|
|
|
|
|
|
|
|
var service = GetService(program);
|
2016-03-02 13:42:39 -05:00
|
|
|
|
var serviceName = service == null ? null : service.Name;
|
|
|
|
|
|
|
|
|
|
if (fields.Contains(ItemFields.ServiceName))
|
2016-02-12 13:29:28 -05:00
|
|
|
|
{
|
2016-03-02 13:42:39 -05:00
|
|
|
|
dto.ServiceName = serviceName;
|
2016-02-12 13:29:28 -05:00
|
|
|
|
}
|
2016-03-02 13:42:39 -05:00
|
|
|
|
|
|
|
|
|
recordingTuples.Add(new Tuple<BaseItemDto, string, string>(dto, serviceName, program.ExternalId));
|
2016-02-12 13:29:28 -05:00
|
|
|
|
}
|
2016-03-02 13:42:39 -05:00
|
|
|
|
|
|
|
|
|
await AddRecordingInfo(recordingTuples, CancellationToken.None).ConfigureAwait(false);
|
2015-05-31 15:12:58 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
public void AddInfoToRecordingDto(BaseItem item, BaseItemDto dto, User user = null)
|
2014-08-14 09:24:30 -04:00
|
|
|
|
{
|
2015-05-31 14:22:51 -04:00
|
|
|
|
var recording = (ILiveTvRecording)item;
|
|
|
|
|
var service = GetService(recording);
|
2014-08-14 09:24:30 -04:00
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
var channel = string.IsNullOrWhiteSpace(recording.ChannelId) ? null : GetInternalChannel(recording.ChannelId);
|
2014-08-14 09:24:30 -04:00
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
var info = recording;
|
2015-05-31 14:22:51 -04:00
|
|
|
|
|
|
|
|
|
dto.SeriesTimerId = string.IsNullOrEmpty(info.SeriesTimerId)
|
|
|
|
|
? null
|
|
|
|
|
: _tvDtoService.GetInternalSeriesTimerId(service.Name, info.SeriesTimerId).ToString("N");
|
|
|
|
|
|
|
|
|
|
dto.StartDate = info.StartDate;
|
|
|
|
|
dto.RecordingStatus = info.Status;
|
|
|
|
|
dto.IsRepeat = info.IsRepeat;
|
|
|
|
|
dto.EpisodeTitle = info.EpisodeTitle;
|
|
|
|
|
dto.IsMovie = info.IsMovie;
|
|
|
|
|
dto.IsSeries = info.IsSeries;
|
|
|
|
|
dto.IsSports = info.IsSports;
|
|
|
|
|
dto.IsLive = info.IsLive;
|
|
|
|
|
dto.IsNews = info.IsNews;
|
|
|
|
|
dto.IsKids = info.IsKids;
|
|
|
|
|
dto.IsPremiere = info.IsPremiere;
|
|
|
|
|
|
|
|
|
|
dto.CanDelete = user == null
|
|
|
|
|
? recording.CanDelete()
|
|
|
|
|
: recording.CanDelete(user);
|
|
|
|
|
|
|
|
|
|
if (dto.MediaSources == null)
|
|
|
|
|
{
|
|
|
|
|
dto.MediaSources = recording.GetMediaSources(true).ToList();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (dto.MediaStreams == null)
|
|
|
|
|
{
|
|
|
|
|
dto.MediaStreams = dto.MediaSources.SelectMany(i => i.MediaStreams).ToList();
|
|
|
|
|
}
|
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
if (info.Status == RecordingStatus.InProgress && info.EndDate.HasValue)
|
2015-05-31 14:22:51 -04:00
|
|
|
|
{
|
|
|
|
|
var now = DateTime.UtcNow.Ticks;
|
|
|
|
|
var start = info.StartDate.Ticks;
|
2015-06-01 13:07:55 -04:00
|
|
|
|
var end = info.EndDate.Value.Ticks;
|
2015-05-31 14:22:51 -04:00
|
|
|
|
|
|
|
|
|
var pct = now - start;
|
|
|
|
|
pct /= end;
|
|
|
|
|
pct *= 100;
|
|
|
|
|
dto.CompletionPercentage = pct;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (channel != null)
|
|
|
|
|
{
|
|
|
|
|
dto.ChannelName = channel.Name;
|
|
|
|
|
|
2015-10-16 13:06:31 -04:00
|
|
|
|
if (channel.HasImage(ImageType.Primary))
|
2013-12-22 22:46:03 -05:00
|
|
|
|
{
|
2015-05-31 14:22:51 -04:00
|
|
|
|
dto.ChannelPrimaryImageTag = _tvDtoService.GetImageTag(channel);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2015-03-19 12:16:33 -04:00
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
public async Task<QueryResult<BaseItemDto>> GetRecordings(RecordingQuery query, DtoOptions options, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var user = string.IsNullOrEmpty(query.UserId) ? null : _userManager.GetUserById(query.UserId);
|
|
|
|
|
|
|
|
|
|
var internalResult = await GetInternalRecordings(query, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
2016-02-11 13:29:42 -05:00
|
|
|
|
var tuples = internalResult.Items
|
|
|
|
|
.Select(i => new Tuple<BaseItem, BaseItemDto>(i, _dtoService.GetBaseItemDto(i, options, user)))
|
2013-11-27 14:04:19 -05:00
|
|
|
|
.ToArray();
|
2013-11-25 21:53:48 -05:00
|
|
|
|
|
2015-04-12 14:58:21 -04:00
|
|
|
|
if (user != null)
|
|
|
|
|
{
|
2016-02-11 13:29:42 -05:00
|
|
|
|
_dtoService.FillSyncInfo(tuples, new DtoOptions(), user);
|
2015-04-12 14:58:21 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
return new QueryResult<BaseItemDto>
|
2013-11-25 21:53:48 -05:00
|
|
|
|
{
|
2016-02-11 13:29:42 -05:00
|
|
|
|
Items = tuples.Select(i => i.Item2).ToArray(),
|
2014-08-14 09:24:30 -04:00
|
|
|
|
TotalRecordCount = internalResult.TotalRecordCount
|
2013-11-25 21:53:48 -05:00
|
|
|
|
};
|
|
|
|
|
}
|
2013-11-26 16:36:11 -05:00
|
|
|
|
|
2013-11-27 14:04:19 -05:00
|
|
|
|
public async Task<QueryResult<TimerInfoDto>> GetTimers(TimerQuery query, CancellationToken cancellationToken)
|
|
|
|
|
{
|
2015-03-22 19:55:33 -04:00
|
|
|
|
var tasks = _services.Select(async i =>
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
var recs = await i.GetTimersAsync(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
return recs.Select(r => new Tuple<TimerInfo, ILiveTvService>(r, i));
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting recordings", ex);
|
|
|
|
|
return new List<Tuple<TimerInfo, ILiveTvService>>();
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
var results = await Task.WhenAll(tasks).ConfigureAwait(false);
|
|
|
|
|
var timers = results.SelectMany(i => i.ToList());
|
2013-11-27 14:04:19 -05:00
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(query.ChannelId))
|
|
|
|
|
{
|
2013-12-22 12:16:24 -05:00
|
|
|
|
var guid = new Guid(query.ChannelId);
|
2015-03-22 19:55:33 -04:00
|
|
|
|
timers = timers.Where(i => guid == _tvDtoService.GetInternalChannelId(i.Item2.Name, i.Item1.ChannelId));
|
2013-11-27 14:04:19 -05:00
|
|
|
|
}
|
|
|
|
|
|
2014-01-08 00:25:21 -05:00
|
|
|
|
if (!string.IsNullOrEmpty(query.SeriesTimerId))
|
|
|
|
|
{
|
|
|
|
|
var guid = new Guid(query.SeriesTimerId);
|
|
|
|
|
|
|
|
|
|
timers = timers
|
2015-03-22 19:55:33 -04:00
|
|
|
|
.Where(i => _tvDtoService.GetInternalSeriesTimerId(i.Item2.Name, i.Item1.SeriesTimerId) == guid);
|
2014-01-08 00:25:21 -05:00
|
|
|
|
}
|
|
|
|
|
|
2014-03-09 18:14:44 -04:00
|
|
|
|
var returnList = new List<TimerInfoDto>();
|
2013-12-22 12:16:24 -05:00
|
|
|
|
|
2014-03-09 18:14:44 -04:00
|
|
|
|
foreach (var i in timers)
|
|
|
|
|
{
|
2015-03-22 19:55:33 -04:00
|
|
|
|
var program = string.IsNullOrEmpty(i.Item1.ProgramId) ?
|
2014-03-09 18:14:44 -04:00
|
|
|
|
null :
|
2015-03-22 19:55:33 -04:00
|
|
|
|
GetInternalProgram(_tvDtoService.GetInternalProgramId(i.Item2.Name, i.Item1.ProgramId).ToString("N"));
|
2014-03-09 18:14:44 -04:00
|
|
|
|
|
2015-03-22 19:55:33 -04:00
|
|
|
|
var channel = string.IsNullOrEmpty(i.Item1.ChannelId) ? null : GetInternalChannel(_tvDtoService.GetInternalChannelId(i.Item2.Name, i.Item1.ChannelId));
|
2014-03-09 18:14:44 -04:00
|
|
|
|
|
2015-03-22 19:55:33 -04:00
|
|
|
|
returnList.Add(_tvDtoService.GetTimerInfoDto(i.Item1, i.Item2, program, channel));
|
2014-03-09 18:14:44 -04:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var returnArray = returnList
|
2013-12-22 12:16:24 -05:00
|
|
|
|
.OrderBy(i => i.StartDate)
|
2013-11-27 14:04:19 -05:00
|
|
|
|
.ToArray();
|
|
|
|
|
|
|
|
|
|
return new QueryResult<TimerInfoDto>
|
|
|
|
|
{
|
|
|
|
|
Items = returnArray,
|
|
|
|
|
TotalRecordCount = returnArray.Length
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-29 11:58:24 -05:00
|
|
|
|
public async Task DeleteRecording(string recordingId)
|
|
|
|
|
{
|
2015-05-31 14:22:51 -04:00
|
|
|
|
var recording = await GetInternalRecording(recordingId, CancellationToken.None).ConfigureAwait(false);
|
2013-11-29 11:58:24 -05:00
|
|
|
|
|
|
|
|
|
if (recording == null)
|
|
|
|
|
{
|
|
|
|
|
throw new ResourceNotFoundException(string.Format("Recording with Id {0} not found", recordingId));
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-11 23:54:00 -05:00
|
|
|
|
await DeleteRecording(recording).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task DeleteRecording(ILiveTvRecording recording)
|
|
|
|
|
{
|
2015-03-12 11:51:48 -04:00
|
|
|
|
var service = GetService(recording.ServiceName);
|
2013-11-29 11:58:24 -05:00
|
|
|
|
|
2015-10-10 20:39:30 -04:00
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
await service.DeleteRecordingAsync(recording.ExternalId, CancellationToken.None).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
catch (ResourceNotFoundException)
|
|
|
|
|
{
|
2015-10-16 18:36:01 -04:00
|
|
|
|
|
2015-10-10 20:39:30 -04:00
|
|
|
|
}
|
|
|
|
|
|
2016-02-11 13:29:42 -05:00
|
|
|
|
_lastRecordingRefreshTime = DateTime.MinValue;
|
2016-02-11 23:54:00 -05:00
|
|
|
|
|
2015-11-06 10:02:22 -05:00
|
|
|
|
// This is the responsibility of the live tv service
|
|
|
|
|
await _libraryManager.DeleteItem((BaseItem)recording, new DeleteOptions
|
|
|
|
|
{
|
|
|
|
|
DeleteFileLocation = false
|
|
|
|
|
|
|
|
|
|
}).ConfigureAwait(false);
|
2015-10-10 20:39:30 -04:00
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
_lastRecordingRefreshTime = DateTime.MinValue;
|
2013-11-29 11:58:24 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task CancelTimer(string id)
|
|
|
|
|
{
|
2013-12-15 09:19:24 -05:00
|
|
|
|
var timer = await GetTimer(id, CancellationToken.None).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
if (timer == null)
|
2013-11-29 11:58:24 -05:00
|
|
|
|
{
|
2013-12-15 09:19:24 -05:00
|
|
|
|
throw new ResourceNotFoundException(string.Format("Timer with Id {0} not found", id));
|
|
|
|
|
}
|
2013-11-29 11:58:24 -05:00
|
|
|
|
|
2015-03-12 11:51:48 -04:00
|
|
|
|
var service = GetService(timer.ServiceName);
|
2013-12-15 09:19:24 -05:00
|
|
|
|
|
|
|
|
|
await service.CancelTimerAsync(timer.ExternalId, CancellationToken.None).ConfigureAwait(false);
|
2015-06-01 13:07:55 -04:00
|
|
|
|
_lastRecordingRefreshTime = DateTime.MinValue;
|
2013-12-15 09:19:24 -05:00
|
|
|
|
}
|
2013-11-29 11:58:24 -05:00
|
|
|
|
|
2013-12-15 09:19:24 -05:00
|
|
|
|
public async Task CancelSeriesTimer(string id)
|
|
|
|
|
{
|
|
|
|
|
var timer = await GetSeriesTimer(id, CancellationToken.None).ConfigureAwait(false);
|
2013-11-29 11:58:24 -05:00
|
|
|
|
|
|
|
|
|
if (timer == null)
|
|
|
|
|
{
|
|
|
|
|
throw new ResourceNotFoundException(string.Format("Timer with Id {0} not found", id));
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-12 11:51:48 -04:00
|
|
|
|
var service = GetService(timer.ServiceName);
|
2013-11-29 11:58:24 -05:00
|
|
|
|
|
2013-12-15 09:19:24 -05:00
|
|
|
|
await service.CancelSeriesTimerAsync(timer.ExternalId, CancellationToken.None).ConfigureAwait(false);
|
2015-06-01 13:07:55 -04:00
|
|
|
|
_lastRecordingRefreshTime = DateTime.MinValue;
|
2013-11-29 11:58:24 -05:00
|
|
|
|
}
|
2013-12-03 23:18:50 -05:00
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
public async Task<BaseItemDto> GetRecording(string id, DtoOptions options, CancellationToken cancellationToken, User user = null)
|
2013-12-03 23:18:50 -05:00
|
|
|
|
{
|
2015-05-31 14:22:51 -04:00
|
|
|
|
var item = await GetInternalRecording(id, cancellationToken).ConfigureAwait(false);
|
2013-12-14 20:17:57 -05:00
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
if (item == null)
|
|
|
|
|
{
|
|
|
|
|
return null;
|
|
|
|
|
}
|
2013-12-03 23:18:50 -05:00
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
return _dtoService.GetBaseItemDto((BaseItem)item, options, user);
|
2013-12-03 23:18:50 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task<TimerInfoDto> GetTimer(string id, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var results = await GetTimers(new TimerQuery(), cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
2014-11-14 01:27:10 -05:00
|
|
|
|
return results.Items.FirstOrDefault(i => string.Equals(i.Id, id, StringComparison.OrdinalIgnoreCase));
|
2013-12-03 23:18:50 -05:00
|
|
|
|
}
|
2013-12-14 20:17:57 -05:00
|
|
|
|
|
|
|
|
|
public async Task<SeriesTimerInfoDto> GetSeriesTimer(string id, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var results = await GetSeriesTimers(new SeriesTimerQuery(), cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
2014-11-14 01:27:10 -05:00
|
|
|
|
return results.Items.FirstOrDefault(i => string.Equals(i.Id, id, StringComparison.OrdinalIgnoreCase));
|
2013-12-14 20:17:57 -05:00
|
|
|
|
}
|
2013-12-15 09:19:24 -05:00
|
|
|
|
|
2013-12-14 20:17:57 -05:00
|
|
|
|
public async Task<QueryResult<SeriesTimerInfoDto>> GetSeriesTimers(SeriesTimerQuery query, CancellationToken cancellationToken)
|
|
|
|
|
{
|
2015-03-22 19:55:33 -04:00
|
|
|
|
var tasks = _services.Select(async i =>
|
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
var recs = await i.GetSeriesTimersAsync(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
return recs.Select(r => new Tuple<SeriesTimerInfo, ILiveTvService>(r, i));
|
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting recordings", ex);
|
|
|
|
|
return new List<Tuple<SeriesTimerInfo, ILiveTvService>>();
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
var results = await Task.WhenAll(tasks).ConfigureAwait(false);
|
|
|
|
|
var timers = results.SelectMany(i => i.ToList());
|
2013-12-14 20:17:57 -05:00
|
|
|
|
|
2014-01-11 18:07:56 -05:00
|
|
|
|
if (string.Equals(query.SortBy, "Priority", StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
{
|
|
|
|
|
timers = query.SortOrder == SortOrder.Descending ?
|
2015-03-22 19:55:33 -04:00
|
|
|
|
timers.OrderBy(i => i.Item1.Priority).ThenByStringDescending(i => i.Item1.Name) :
|
|
|
|
|
timers.OrderByDescending(i => i.Item1.Priority).ThenByString(i => i.Item1.Name);
|
2014-01-11 18:07:56 -05:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
timers = query.SortOrder == SortOrder.Descending ?
|
2015-03-22 19:55:33 -04:00
|
|
|
|
timers.OrderByStringDescending(i => i.Item1.Name) :
|
|
|
|
|
timers.OrderByString(i => i.Item1.Name);
|
2014-01-11 18:07:56 -05:00
|
|
|
|
}
|
|
|
|
|
|
2013-12-22 13:58:51 -05:00
|
|
|
|
var returnArray = timers
|
2013-12-22 22:46:03 -05:00
|
|
|
|
.Select(i =>
|
|
|
|
|
{
|
|
|
|
|
string channelName = null;
|
|
|
|
|
|
2015-03-22 19:55:33 -04:00
|
|
|
|
if (!string.IsNullOrEmpty(i.Item1.ChannelId))
|
2013-12-22 22:46:03 -05:00
|
|
|
|
{
|
2015-03-22 19:55:33 -04:00
|
|
|
|
var internalChannelId = _tvDtoService.GetInternalChannelId(i.Item2.Name, i.Item1.ChannelId);
|
2013-12-28 11:58:13 -05:00
|
|
|
|
var channel = GetInternalChannel(internalChannelId);
|
2014-01-23 13:05:41 -05:00
|
|
|
|
channelName = channel == null ? null : channel.Name;
|
2013-12-22 22:46:03 -05:00
|
|
|
|
}
|
|
|
|
|
|
2015-03-22 19:55:33 -04:00
|
|
|
|
return _tvDtoService.GetSeriesTimerInfoDto(i.Item1, i.Item2, channelName);
|
2013-12-22 22:46:03 -05:00
|
|
|
|
|
|
|
|
|
})
|
2013-12-14 20:17:57 -05:00
|
|
|
|
.ToArray();
|
|
|
|
|
|
|
|
|
|
return new QueryResult<SeriesTimerInfoDto>
|
|
|
|
|
{
|
|
|
|
|
Items = returnArray,
|
|
|
|
|
TotalRecordCount = returnArray.Length
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2014-03-09 18:14:44 -04:00
|
|
|
|
public async Task<ChannelInfoDto> GetChannel(string id, CancellationToken cancellationToken, User user = null)
|
2013-12-14 20:17:57 -05:00
|
|
|
|
{
|
2013-12-22 12:16:24 -05:00
|
|
|
|
var channel = GetInternalChannel(id);
|
2013-12-14 20:17:57 -05:00
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
var now = DateTime.UtcNow;
|
2013-12-14 20:17:57 -05:00
|
|
|
|
|
2015-11-23 11:04:57 -05:00
|
|
|
|
var programs = _libraryManager.GetItems(new InternalItemsQuery(user)
|
2015-06-01 10:49:23 -04:00
|
|
|
|
{
|
|
|
|
|
IncludeItemTypes = new[] { typeof(LiveTvProgram).Name },
|
|
|
|
|
ChannelIds = new[] { id },
|
|
|
|
|
MaxStartDate = now,
|
|
|
|
|
MinEndDate = now,
|
2015-11-21 00:01:16 -05:00
|
|
|
|
Limit = 1,
|
|
|
|
|
SortBy = new[] { "StartDate" }
|
2013-12-17 15:02:12 -05:00
|
|
|
|
|
2015-11-23 11:04:57 -05:00
|
|
|
|
}, new string[] { }).Cast<LiveTvProgram>();
|
2014-01-02 16:21:06 -05:00
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
var currentProgram = programs.FirstOrDefault();
|
2014-03-09 18:14:44 -04:00
|
|
|
|
|
2015-08-02 13:02:23 -04:00
|
|
|
|
var dto = _tvDtoService.GetChannelInfoDto(channel, new DtoOptions(), currentProgram, user);
|
2014-03-09 18:14:44 -04:00
|
|
|
|
|
2015-06-01 10:49:23 -04:00
|
|
|
|
return dto;
|
2014-01-02 16:21:06 -05:00
|
|
|
|
}
|
|
|
|
|
|
2015-08-31 00:57:12 -04:00
|
|
|
|
public void AddChannelInfo(BaseItemDto dto, LiveTvChannel channel, DtoOptions options, User user)
|
|
|
|
|
{
|
|
|
|
|
dto.MediaSources = channel.GetMediaSources(true).ToList();
|
|
|
|
|
|
|
|
|
|
var now = DateTime.UtcNow;
|
|
|
|
|
|
2015-11-23 11:04:57 -05:00
|
|
|
|
var programs = _libraryManager.GetItems(new InternalItemsQuery(user)
|
2015-08-31 00:57:12 -04:00
|
|
|
|
{
|
|
|
|
|
IncludeItemTypes = new[] { typeof(LiveTvProgram).Name },
|
|
|
|
|
ChannelIds = new[] { channel.Id.ToString("N") },
|
|
|
|
|
MaxStartDate = now,
|
|
|
|
|
MinEndDate = now,
|
2015-11-21 00:01:16 -05:00
|
|
|
|
Limit = 1,
|
|
|
|
|
SortBy = new[] { "StartDate" }
|
2015-08-31 00:57:12 -04:00
|
|
|
|
|
2015-11-23 11:04:57 -05:00
|
|
|
|
}, new string[] { }).Cast<LiveTvProgram>();
|
2015-08-31 00:57:12 -04:00
|
|
|
|
|
2015-11-21 00:01:16 -05:00
|
|
|
|
var currentProgram = programs.FirstOrDefault();
|
2015-08-31 00:57:12 -04:00
|
|
|
|
|
|
|
|
|
if (currentProgram != null)
|
|
|
|
|
{
|
|
|
|
|
dto.CurrentProgram = _dtoService.GetBaseItemDto(currentProgram, options, user);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-20 01:40:51 -04:00
|
|
|
|
private async Task<Tuple<SeriesTimerInfo, ILiveTvService>> GetNewTimerDefaultsInternal(CancellationToken cancellationToken, LiveTvProgram program = null)
|
2013-12-17 15:02:12 -05:00
|
|
|
|
{
|
2015-03-19 12:16:33 -04:00
|
|
|
|
var service = program != null && !string.IsNullOrWhiteSpace(program.ServiceName) ?
|
|
|
|
|
GetService(program) :
|
|
|
|
|
_services.FirstOrDefault();
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
ProgramInfo programInfo = null;
|
|
|
|
|
|
|
|
|
|
if (program != null)
|
|
|
|
|
{
|
2015-06-01 10:49:23 -04:00
|
|
|
|
var channel = GetInternalChannel(program.ChannelId);
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
programInfo = new ProgramInfo
|
|
|
|
|
{
|
|
|
|
|
Audio = program.Audio,
|
2015-06-01 10:49:23 -04:00
|
|
|
|
ChannelId = channel.ExternalId,
|
2014-01-23 13:05:41 -05:00
|
|
|
|
CommunityRating = program.CommunityRating,
|
|
|
|
|
EndDate = program.EndDate ?? DateTime.MinValue,
|
|
|
|
|
EpisodeTitle = program.EpisodeTitle,
|
|
|
|
|
Genres = program.Genres,
|
|
|
|
|
Id = program.ExternalId,
|
|
|
|
|
IsHD = program.IsHD,
|
|
|
|
|
IsKids = program.IsKids,
|
|
|
|
|
IsLive = program.IsLive,
|
|
|
|
|
IsMovie = program.IsMovie,
|
|
|
|
|
IsNews = program.IsNews,
|
|
|
|
|
IsPremiere = program.IsPremiere,
|
|
|
|
|
IsRepeat = program.IsRepeat,
|
|
|
|
|
IsSeries = program.IsSeries,
|
|
|
|
|
IsSports = program.IsSports,
|
|
|
|
|
OriginalAirDate = program.PremiereDate,
|
|
|
|
|
Overview = program.Overview,
|
|
|
|
|
StartDate = program.StartDate,
|
2015-10-25 13:13:30 -04:00
|
|
|
|
//ImagePath = program.ExternalImagePath,
|
2014-01-23 13:05:41 -05:00
|
|
|
|
Name = program.Name,
|
2015-08-16 18:03:22 -04:00
|
|
|
|
OfficialRating = program.OfficialRating
|
2014-01-23 13:05:41 -05:00
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-19 12:16:33 -04:00
|
|
|
|
var info = await service.GetNewTimerDefaultsAsync(cancellationToken, programInfo).ConfigureAwait(false);
|
2013-12-22 13:58:51 -05:00
|
|
|
|
|
2014-01-13 15:31:09 -05:00
|
|
|
|
info.Id = null;
|
2013-12-17 15:02:12 -05:00
|
|
|
|
|
2015-03-19 12:16:33 -04:00
|
|
|
|
return new Tuple<SeriesTimerInfo, ILiveTvService>(info, service);
|
2014-01-13 15:31:09 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task<SeriesTimerInfoDto> GetNewTimerDefaults(CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var info = await GetNewTimerDefaultsInternal(cancellationToken).ConfigureAwait(false);
|
2013-12-18 00:44:46 -05:00
|
|
|
|
|
2015-03-19 12:16:33 -04:00
|
|
|
|
var obj = _tvDtoService.GetSeriesTimerInfoDto(info.Item1, info.Item2, null);
|
2013-12-18 00:44:46 -05:00
|
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task<SeriesTimerInfoDto> GetNewTimerDefaults(string programId, CancellationToken cancellationToken)
|
|
|
|
|
{
|
2015-03-14 16:00:32 -04:00
|
|
|
|
var program = GetInternalProgram(programId);
|
2014-01-13 15:31:09 -05:00
|
|
|
|
var programDto = await GetProgram(programId, cancellationToken).ConfigureAwait(false);
|
2013-12-18 00:44:46 -05:00
|
|
|
|
|
2014-01-13 15:31:09 -05:00
|
|
|
|
var defaults = await GetNewTimerDefaultsInternal(cancellationToken, program).ConfigureAwait(false);
|
2015-03-19 12:16:33 -04:00
|
|
|
|
var info = _tvDtoService.GetSeriesTimerInfoDto(defaults.Item1, defaults.Item2, null);
|
2013-12-18 00:44:46 -05:00
|
|
|
|
|
|
|
|
|
info.Days = new List<DayOfWeek>
|
|
|
|
|
{
|
|
|
|
|
program.StartDate.ToLocalTime().DayOfWeek
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
info.DayPattern = _tvDtoService.GetDayPattern(info.Days);
|
|
|
|
|
|
|
|
|
|
info.Name = program.Name;
|
2014-01-14 15:03:35 -05:00
|
|
|
|
info.ChannelId = programDto.ChannelId;
|
2014-01-13 15:31:09 -05:00
|
|
|
|
info.ChannelName = programDto.ChannelName;
|
2013-12-18 00:44:46 -05:00
|
|
|
|
info.StartDate = program.StartDate;
|
|
|
|
|
info.Name = program.Name;
|
|
|
|
|
info.Overview = program.Overview;
|
2014-01-14 15:03:35 -05:00
|
|
|
|
info.ProgramId = programDto.Id;
|
2015-05-31 15:12:58 -04:00
|
|
|
|
info.ExternalProgramId = program.ExternalId;
|
2013-12-18 00:44:46 -05:00
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
if (program.EndDate.HasValue)
|
|
|
|
|
{
|
|
|
|
|
info.EndDate = program.EndDate.Value;
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-18 00:44:46 -05:00
|
|
|
|
return info;
|
2013-12-17 15:02:12 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task CreateTimer(TimerInfoDto timer, CancellationToken cancellationToken)
|
|
|
|
|
{
|
2015-03-12 11:51:48 -04:00
|
|
|
|
var service = GetService(timer.ServiceName);
|
2013-12-17 15:02:12 -05:00
|
|
|
|
|
|
|
|
|
var info = await _tvDtoService.GetTimerInfo(timer, true, this, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
2013-12-18 00:44:46 -05:00
|
|
|
|
// Set priority from default values
|
|
|
|
|
var defaultValues = await service.GetNewTimerDefaultsAsync(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
info.Priority = defaultValues.Priority;
|
|
|
|
|
|
2013-12-17 15:02:12 -05:00
|
|
|
|
await service.CreateTimerAsync(info, cancellationToken).ConfigureAwait(false);
|
2015-06-01 13:07:55 -04:00
|
|
|
|
_lastRecordingRefreshTime = DateTime.MinValue;
|
2016-01-21 12:45:42 -05:00
|
|
|
|
_logger.Info("New recording scheduled");
|
2013-12-17 15:02:12 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task CreateSeriesTimer(SeriesTimerInfoDto timer, CancellationToken cancellationToken)
|
|
|
|
|
{
|
2015-03-12 11:51:48 -04:00
|
|
|
|
var service = GetService(timer.ServiceName);
|
2013-12-17 15:02:12 -05:00
|
|
|
|
|
|
|
|
|
var info = await _tvDtoService.GetSeriesTimerInfo(timer, true, this, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
2013-12-18 00:44:46 -05:00
|
|
|
|
// Set priority from default values
|
|
|
|
|
var defaultValues = await service.GetNewTimerDefaultsAsync(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
info.Priority = defaultValues.Priority;
|
|
|
|
|
|
2013-12-17 15:02:12 -05:00
|
|
|
|
await service.CreateSeriesTimerAsync(info, cancellationToken).ConfigureAwait(false);
|
2015-06-01 13:07:55 -04:00
|
|
|
|
_lastRecordingRefreshTime = DateTime.MinValue;
|
2013-12-17 15:02:12 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task UpdateTimer(TimerInfoDto timer, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var info = await _tvDtoService.GetTimerInfo(timer, false, this, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
2015-03-12 11:51:48 -04:00
|
|
|
|
var service = GetService(timer.ServiceName);
|
2013-12-17 15:02:12 -05:00
|
|
|
|
|
|
|
|
|
await service.UpdateTimerAsync(info, cancellationToken).ConfigureAwait(false);
|
2015-06-01 13:07:55 -04:00
|
|
|
|
_lastRecordingRefreshTime = DateTime.MinValue;
|
2013-12-17 15:02:12 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task UpdateSeriesTimer(SeriesTimerInfoDto timer, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var info = await _tvDtoService.GetSeriesTimerInfo(timer, false, this, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
2015-03-12 11:51:48 -04:00
|
|
|
|
var service = GetService(timer.ServiceName);
|
2013-12-17 15:02:12 -05:00
|
|
|
|
|
|
|
|
|
await service.UpdateSeriesTimerAsync(info, cancellationToken).ConfigureAwait(false);
|
2015-06-01 13:07:55 -04:00
|
|
|
|
_lastRecordingRefreshTime = DateTime.MinValue;
|
2013-12-17 15:02:12 -05:00
|
|
|
|
}
|
2013-12-28 16:37:01 -05:00
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
private IEnumerable<string> GetRecordingGroupNames(ILiveTvRecording recording)
|
2013-12-28 16:37:01 -05:00
|
|
|
|
{
|
|
|
|
|
var list = new List<string>();
|
|
|
|
|
|
|
|
|
|
if (recording.IsSeries)
|
|
|
|
|
{
|
|
|
|
|
list.Add(recording.Name);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (recording.IsKids)
|
|
|
|
|
{
|
|
|
|
|
list.Add("Kids");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (recording.IsMovie)
|
|
|
|
|
{
|
|
|
|
|
list.Add("Movies");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (recording.IsNews)
|
|
|
|
|
{
|
|
|
|
|
list.Add("News");
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-03 15:43:54 -05:00
|
|
|
|
if (recording.IsSports)
|
2013-12-28 16:37:01 -05:00
|
|
|
|
{
|
|
|
|
|
list.Add("Sports");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!recording.IsSports && !recording.IsNews && !recording.IsMovie && !recording.IsKids && !recording.IsSeries)
|
|
|
|
|
{
|
|
|
|
|
list.Add("Others");
|
|
|
|
|
}
|
2013-12-28 18:09:24 -05:00
|
|
|
|
|
2013-12-28 16:37:01 -05:00
|
|
|
|
return list;
|
|
|
|
|
}
|
2013-12-28 18:09:24 -05:00
|
|
|
|
|
2015-06-01 13:07:55 -04:00
|
|
|
|
private List<Guid> GetRecordingGroupIds(ILiveTvRecording recording)
|
2013-12-28 16:37:01 -05:00
|
|
|
|
{
|
|
|
|
|
return GetRecordingGroupNames(recording).Select(i => i.ToLower()
|
|
|
|
|
.GetMD5())
|
|
|
|
|
.ToList();
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
public async Task<QueryResult<BaseItemDto>> GetRecordingGroups(RecordingGroupQuery query, CancellationToken cancellationToken)
|
2013-12-28 16:37:01 -05:00
|
|
|
|
{
|
2015-05-31 14:22:51 -04:00
|
|
|
|
var recordingResult = await GetInternalRecordings(new RecordingQuery
|
2013-12-28 16:37:01 -05:00
|
|
|
|
{
|
|
|
|
|
UserId = query.UserId
|
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
}, cancellationToken).ConfigureAwait(false);
|
2013-12-28 16:37:01 -05:00
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
var recordings = recordingResult.Items.Cast<ILiveTvRecording>().ToList();
|
2013-12-28 16:37:01 -05:00
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
var groups = new List<BaseItemDto>();
|
2013-12-28 16:37:01 -05:00
|
|
|
|
|
|
|
|
|
var series = recordings
|
2015-06-01 13:07:55 -04:00
|
|
|
|
.Where(i => i.IsSeries)
|
2013-12-28 16:37:01 -05:00
|
|
|
|
.ToLookup(i => i.Name, StringComparer.OrdinalIgnoreCase)
|
|
|
|
|
.ToList();
|
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
groups.AddRange(series.OrderByString(i => i.Key).Select(i => new BaseItemDto
|
2013-12-28 16:37:01 -05:00
|
|
|
|
{
|
|
|
|
|
Name = i.Key,
|
|
|
|
|
RecordingCount = i.Count()
|
|
|
|
|
}));
|
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
groups.Add(new BaseItemDto
|
2013-12-28 16:37:01 -05:00
|
|
|
|
{
|
|
|
|
|
Name = "Kids",
|
2015-06-01 13:07:55 -04:00
|
|
|
|
RecordingCount = recordings.Count(i => i.IsKids)
|
2013-12-28 16:37:01 -05:00
|
|
|
|
});
|
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
groups.Add(new BaseItemDto
|
2013-12-28 16:37:01 -05:00
|
|
|
|
{
|
|
|
|
|
Name = "Movies",
|
2015-06-01 13:07:55 -04:00
|
|
|
|
RecordingCount = recordings.Count(i => i.IsMovie)
|
2013-12-28 16:37:01 -05:00
|
|
|
|
});
|
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
groups.Add(new BaseItemDto
|
2013-12-28 16:37:01 -05:00
|
|
|
|
{
|
|
|
|
|
Name = "News",
|
2015-06-01 13:07:55 -04:00
|
|
|
|
RecordingCount = recordings.Count(i => i.IsNews)
|
2013-12-28 16:37:01 -05:00
|
|
|
|
});
|
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
groups.Add(new BaseItemDto
|
2013-12-28 16:37:01 -05:00
|
|
|
|
{
|
|
|
|
|
Name = "Sports",
|
2015-06-01 13:07:55 -04:00
|
|
|
|
RecordingCount = recordings.Count(i => i.IsSports)
|
2013-12-28 16:37:01 -05:00
|
|
|
|
});
|
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
groups.Add(new BaseItemDto
|
2013-12-28 16:37:01 -05:00
|
|
|
|
{
|
|
|
|
|
Name = "Others",
|
2015-06-01 13:07:55 -04:00
|
|
|
|
RecordingCount = recordings.Count(i => !i.IsSports && !i.IsNews && !i.IsMovie && !i.IsKids && !i.IsSeries)
|
2013-12-28 16:37:01 -05:00
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
groups = groups
|
|
|
|
|
.Where(i => i.RecordingCount > 0)
|
|
|
|
|
.ToList();
|
|
|
|
|
|
|
|
|
|
foreach (var group in groups)
|
|
|
|
|
{
|
|
|
|
|
group.Id = group.Name.ToLower().GetMD5().ToString("N");
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-31 14:22:51 -04:00
|
|
|
|
return new QueryResult<BaseItemDto>
|
2013-12-28 16:37:01 -05:00
|
|
|
|
{
|
|
|
|
|
Items = groups.ToArray(),
|
|
|
|
|
TotalRecordCount = groups.Count
|
|
|
|
|
};
|
|
|
|
|
}
|
2014-01-05 01:50:48 -05:00
|
|
|
|
|
2014-07-02 14:34:08 -04:00
|
|
|
|
class LiveStreamData
|
|
|
|
|
{
|
2015-03-20 01:40:51 -04:00
|
|
|
|
internal MediaSourceInfo Info;
|
2014-07-02 14:34:08 -04:00
|
|
|
|
internal string ItemId;
|
|
|
|
|
internal bool IsChannel;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-17 11:36:01 -05:00
|
|
|
|
public async Task CloseLiveStream(string id, CancellationToken cancellationToken)
|
2014-01-05 01:50:48 -05:00
|
|
|
|
{
|
2014-01-17 11:36:01 -05:00
|
|
|
|
await _liveStreamSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
try
|
|
|
|
|
{
|
2015-03-29 23:04:55 -04:00
|
|
|
|
var parts = id.Split(new[] { '_' }, 2);
|
2014-07-02 14:34:08 -04:00
|
|
|
|
|
2015-03-29 23:04:55 -04:00
|
|
|
|
var service = _services.FirstOrDefault(i => string.Equals(i.GetType().FullName.GetMD5().ToString("N"), parts[0], StringComparison.OrdinalIgnoreCase));
|
2014-05-27 17:17:48 -04:00
|
|
|
|
|
2015-03-29 23:04:55 -04:00
|
|
|
|
if (service == null)
|
|
|
|
|
{
|
|
|
|
|
throw new ArgumentException("Service not found.");
|
2014-07-02 14:34:08 -04:00
|
|
|
|
}
|
2015-03-29 23:04:55 -04:00
|
|
|
|
|
|
|
|
|
id = parts[1];
|
|
|
|
|
|
|
|
|
|
LiveStreamData data;
|
2014-07-02 14:34:08 -04:00
|
|
|
|
_openStreams.TryRemove(id, out data);
|
|
|
|
|
|
|
|
|
|
_logger.Info("Closing live stream from {0}, stream Id: {1}", service.Name, id);
|
|
|
|
|
|
|
|
|
|
await service.CloseLiveStream(id, cancellationToken).ConfigureAwait(false);
|
2014-01-18 23:25:01 -05:00
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error closing live stream", ex);
|
|
|
|
|
|
|
|
|
|
throw;
|
2014-01-17 11:36:01 -05:00
|
|
|
|
}
|
|
|
|
|
finally
|
|
|
|
|
{
|
|
|
|
|
_liveStreamSemaphore.Release();
|
|
|
|
|
}
|
2014-01-05 01:50:48 -05:00
|
|
|
|
}
|
2014-01-07 13:39:35 -05:00
|
|
|
|
|
|
|
|
|
public GuideInfo GetGuideInfo()
|
|
|
|
|
{
|
2015-06-01 10:49:23 -04:00
|
|
|
|
var startDate = DateTime.UtcNow;
|
|
|
|
|
var endDate = startDate.AddDays(14);
|
2014-01-07 13:39:35 -05:00
|
|
|
|
|
|
|
|
|
return new GuideInfo
|
|
|
|
|
{
|
|
|
|
|
StartDate = startDate,
|
|
|
|
|
EndDate = endDate
|
|
|
|
|
};
|
|
|
|
|
}
|
2014-01-12 01:31:21 -05:00
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
|
|
|
|
|
/// </summary>
|
|
|
|
|
public void Dispose()
|
|
|
|
|
{
|
|
|
|
|
Dispose(true);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private readonly object _disposeLock = new object();
|
|
|
|
|
/// <summary>
|
|
|
|
|
/// Releases unmanaged and - optionally - managed resources.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
|
|
|
|
|
protected virtual void Dispose(bool dispose)
|
|
|
|
|
{
|
|
|
|
|
if (dispose)
|
|
|
|
|
{
|
|
|
|
|
lock (_disposeLock)
|
|
|
|
|
{
|
|
|
|
|
foreach (var stream in _openStreams.Values.ToList())
|
|
|
|
|
{
|
2014-07-02 14:34:08 -04:00
|
|
|
|
var task = CloseLiveStream(stream.Info.Id, CancellationToken.None);
|
2014-01-12 01:31:21 -05:00
|
|
|
|
|
|
|
|
|
Task.WaitAll(task);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
_openStreams.Clear();
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
2014-01-16 12:23:30 -05:00
|
|
|
|
|
2014-01-23 17:15:15 -05:00
|
|
|
|
private async Task<IEnumerable<LiveTvServiceInfo>> GetServiceInfos(CancellationToken cancellationToken)
|
2014-01-16 12:23:30 -05:00
|
|
|
|
{
|
|
|
|
|
var tasks = Services.Select(i => GetServiceInfo(i, cancellationToken));
|
|
|
|
|
|
|
|
|
|
return await Task.WhenAll(tasks).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private async Task<LiveTvServiceInfo> GetServiceInfo(ILiveTvService service, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var info = new LiveTvServiceInfo
|
|
|
|
|
{
|
|
|
|
|
Name = service.Name
|
|
|
|
|
};
|
|
|
|
|
|
2015-03-29 23:04:55 -04:00
|
|
|
|
var tunerIdPrefix = service.GetType().FullName.GetMD5().ToString("N") + "_";
|
|
|
|
|
|
2014-01-16 12:23:30 -05:00
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
var statusInfo = await service.GetStatusInfoAsync(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
info.Status = statusInfo.Status;
|
|
|
|
|
info.StatusMessage = statusInfo.StatusMessage;
|
2014-01-17 15:51:29 -05:00
|
|
|
|
info.Version = statusInfo.Version;
|
|
|
|
|
info.HasUpdateAvailable = statusInfo.HasUpdateAvailable;
|
|
|
|
|
info.HomePageUrl = service.HomePageUrl;
|
2015-07-21 00:22:46 -04:00
|
|
|
|
info.IsVisible = statusInfo.IsVisible;
|
2014-01-23 17:15:15 -05:00
|
|
|
|
|
2014-01-24 13:09:50 -05:00
|
|
|
|
info.Tuners = statusInfo.Tuners.Select(i =>
|
|
|
|
|
{
|
|
|
|
|
string channelName = null;
|
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(i.ChannelId))
|
|
|
|
|
{
|
|
|
|
|
var internalChannelId = _tvDtoService.GetInternalChannelId(service.Name, i.ChannelId);
|
|
|
|
|
var channel = GetInternalChannel(internalChannelId);
|
|
|
|
|
channelName = channel == null ? null : channel.Name;
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-29 23:04:55 -04:00
|
|
|
|
var dto = _tvDtoService.GetTunerInfoDto(service.Name, i, channelName);
|
|
|
|
|
|
|
|
|
|
dto.Id = tunerIdPrefix + dto.Id;
|
|
|
|
|
|
|
|
|
|
return dto;
|
2014-01-24 13:09:50 -05:00
|
|
|
|
|
|
|
|
|
}).ToList();
|
2014-01-16 12:23:30 -05:00
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
2014-05-21 23:35:18 -04:00
|
|
|
|
_logger.ErrorException("Error getting service status info from {0}", ex, service.Name ?? string.Empty);
|
2014-01-16 12:23:30 -05:00
|
|
|
|
|
|
|
|
|
info.Status = LiveTvServiceStatus.Unavailable;
|
|
|
|
|
info.StatusMessage = ex.Message;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return info;
|
|
|
|
|
}
|
2014-01-23 17:15:15 -05:00
|
|
|
|
|
|
|
|
|
public async Task<LiveTvInfo> GetLiveTvInfo(CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var services = await GetServiceInfos(CancellationToken.None).ConfigureAwait(false);
|
|
|
|
|
var servicesList = services.ToList();
|
|
|
|
|
|
|
|
|
|
var info = new LiveTvInfo
|
|
|
|
|
{
|
|
|
|
|
Services = servicesList.ToList(),
|
2015-03-12 11:51:48 -04:00
|
|
|
|
IsEnabled = servicesList.Count > 0
|
2014-01-23 17:15:15 -05:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
info.EnabledUsers = _userManager.Users
|
2014-06-23 12:05:19 -04:00
|
|
|
|
.Where(IsLiveTvEnabled)
|
2014-01-23 17:15:15 -05:00
|
|
|
|
.Select(i => i.Id.ToString("N"))
|
|
|
|
|
.ToList();
|
|
|
|
|
|
|
|
|
|
return info;
|
|
|
|
|
}
|
|
|
|
|
|
2014-06-23 12:05:19 -04:00
|
|
|
|
private bool IsLiveTvEnabled(User user)
|
|
|
|
|
{
|
2015-07-27 12:21:18 -04:00
|
|
|
|
return user.Policy.EnableLiveTvAccess && (Services.Count > 1 || GetConfiguration().TunerHosts.Count(i => i.IsEnabled) > 0);
|
2014-06-23 12:05:19 -04:00
|
|
|
|
}
|
|
|
|
|
|
2014-06-10 13:36:06 -04:00
|
|
|
|
public IEnumerable<User> GetEnabledUsers()
|
|
|
|
|
{
|
|
|
|
|
return _userManager.Users
|
2015-03-12 10:59:08 -04:00
|
|
|
|
.Where(IsLiveTvEnabled);
|
2014-06-10 13:36:06 -04:00
|
|
|
|
}
|
|
|
|
|
|
2014-01-23 17:15:15 -05:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Resets the tuner.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="id">The identifier.</param>
|
|
|
|
|
/// <param name="cancellationToken">The cancellation token.</param>
|
|
|
|
|
/// <returns>Task.</returns>
|
|
|
|
|
public Task ResetTuner(string id, CancellationToken cancellationToken)
|
|
|
|
|
{
|
2015-03-29 23:04:55 -04:00
|
|
|
|
var parts = id.Split(new[] { '_' }, 2);
|
|
|
|
|
|
|
|
|
|
var service = _services.FirstOrDefault(i => string.Equals(i.GetType().FullName.GetMD5().ToString("N"), parts[0], StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
|
|
|
|
|
if (service == null)
|
|
|
|
|
{
|
|
|
|
|
throw new ArgumentException("Service not found.");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return service.ResetTuner(parts[1], cancellationToken);
|
2014-01-23 17:15:15 -05:00
|
|
|
|
}
|
2014-06-07 15:46:24 -04:00
|
|
|
|
|
|
|
|
|
public async Task<BaseItemDto> GetLiveTvFolder(string userId, CancellationToken cancellationToken)
|
|
|
|
|
{
|
2014-09-14 11:10:51 -04:00
|
|
|
|
var user = string.IsNullOrEmpty(userId) ? null : _userManager.GetUserById(userId);
|
2014-06-07 15:46:24 -04:00
|
|
|
|
|
2015-08-14 15:14:54 -04:00
|
|
|
|
var folder = await GetInternalLiveTvFolder(cancellationToken).ConfigureAwait(false);
|
2014-06-07 15:46:24 -04:00
|
|
|
|
|
2014-12-27 00:08:39 -05:00
|
|
|
|
return _dtoService.GetBaseItemDto(folder, new DtoOptions(), user);
|
2014-06-07 15:46:24 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-08-14 15:14:54 -04:00
|
|
|
|
public async Task<Folder> GetInternalLiveTvFolder(CancellationToken cancellationToken)
|
2014-06-07 15:46:24 -04:00
|
|
|
|
{
|
|
|
|
|
var name = _localization.GetLocalizedString("ViewTypeLiveTV");
|
2015-11-21 00:01:16 -05:00
|
|
|
|
return await _libraryManager.GetNamedView(name, CollectionType.LiveTv, name, cancellationToken).ConfigureAwait(false);
|
2014-06-07 15:46:24 -04:00
|
|
|
|
}
|
2015-07-23 09:23:22 -04:00
|
|
|
|
|
2015-07-25 14:11:46 -04:00
|
|
|
|
public async Task<TunerHostInfo> SaveTunerHost(TunerHostInfo info)
|
2015-07-23 09:23:22 -04:00
|
|
|
|
{
|
|
|
|
|
info = (TunerHostInfo)_jsonSerializer.DeserializeFromString(_jsonSerializer.SerializeToString(info), typeof(TunerHostInfo));
|
2015-07-27 12:21:18 -04:00
|
|
|
|
|
2015-07-23 09:23:22 -04:00
|
|
|
|
var provider = _tunerHosts.FirstOrDefault(i => string.Equals(info.Type, i.Type, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
|
|
|
|
|
if (provider == null)
|
|
|
|
|
{
|
|
|
|
|
throw new ResourceNotFoundException();
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-19 01:20:18 -05:00
|
|
|
|
var configurable = provider as IConfigurableTunerHost;
|
|
|
|
|
if (configurable != null)
|
|
|
|
|
{
|
|
|
|
|
await configurable.Validate(info).ConfigureAwait(false);
|
|
|
|
|
}
|
2015-07-23 09:23:22 -04:00
|
|
|
|
|
|
|
|
|
var config = GetConfiguration();
|
|
|
|
|
|
|
|
|
|
var index = config.TunerHosts.FindIndex(i => string.Equals(i.Id, info.Id, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
|
|
|
|
|
if (index == -1 || string.IsNullOrWhiteSpace(info.Id))
|
|
|
|
|
{
|
|
|
|
|
info.Id = Guid.NewGuid().ToString("N");
|
|
|
|
|
config.TunerHosts.Add(info);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
config.TunerHosts[index] = info;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
_config.SaveConfiguration("livetv", config);
|
2015-07-23 13:04:54 -04:00
|
|
|
|
|
|
|
|
|
_taskManager.CancelIfRunningAndQueue<RefreshChannelsScheduledTask>();
|
2015-07-25 14:11:46 -04:00
|
|
|
|
|
|
|
|
|
return info;
|
2015-07-23 09:23:22 -04:00
|
|
|
|
}
|
|
|
|
|
|
2015-07-25 13:21:10 -04:00
|
|
|
|
public async Task<ListingsProviderInfo> SaveListingProvider(ListingsProviderInfo info, bool validateLogin, bool validateListings)
|
2015-07-23 09:23:22 -04:00
|
|
|
|
{
|
|
|
|
|
info = (ListingsProviderInfo)_jsonSerializer.DeserializeFromString(_jsonSerializer.SerializeToString(info), typeof(ListingsProviderInfo));
|
|
|
|
|
|
|
|
|
|
var provider = _listingProviders.FirstOrDefault(i => string.Equals(info.Type, i.Type, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
|
|
|
|
|
if (provider == null)
|
|
|
|
|
{
|
|
|
|
|
throw new ResourceNotFoundException();
|
|
|
|
|
}
|
|
|
|
|
|
2015-07-25 13:21:10 -04:00
|
|
|
|
await provider.Validate(info, validateLogin, validateListings).ConfigureAwait(false);
|
2015-07-23 09:23:22 -04:00
|
|
|
|
|
|
|
|
|
var config = GetConfiguration();
|
|
|
|
|
|
|
|
|
|
var index = config.ListingProviders.FindIndex(i => string.Equals(i.Id, info.Id, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
|
|
|
|
|
if (index == -1 || string.IsNullOrWhiteSpace(info.Id))
|
|
|
|
|
{
|
|
|
|
|
info.Id = Guid.NewGuid().ToString("N");
|
|
|
|
|
config.ListingProviders.Add(info);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
config.ListingProviders[index] = info;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
_config.SaveConfiguration("livetv", config);
|
|
|
|
|
|
2015-07-23 13:04:54 -04:00
|
|
|
|
_taskManager.CancelIfRunningAndQueue<RefreshChannelsScheduledTask>();
|
2015-07-27 12:21:18 -04:00
|
|
|
|
|
2015-07-23 09:23:22 -04:00
|
|
|
|
return info;
|
|
|
|
|
}
|
|
|
|
|
|
2015-08-10 15:09:10 -04:00
|
|
|
|
public Task<List<NameIdPair>> GetLineups(string providerType, string providerId, string country, string location)
|
2015-07-23 09:23:22 -04:00
|
|
|
|
{
|
|
|
|
|
var config = GetConfiguration();
|
|
|
|
|
|
2015-08-10 15:09:10 -04:00
|
|
|
|
if (string.IsNullOrWhiteSpace(providerId))
|
|
|
|
|
{
|
|
|
|
|
var provider = _listingProviders.FirstOrDefault(i => string.Equals(providerType, i.Type, StringComparison.OrdinalIgnoreCase));
|
2015-07-23 09:23:22 -04:00
|
|
|
|
|
2015-08-10 15:09:10 -04:00
|
|
|
|
if (provider == null)
|
|
|
|
|
{
|
|
|
|
|
throw new ResourceNotFoundException();
|
|
|
|
|
}
|
2015-07-23 09:23:22 -04:00
|
|
|
|
|
2015-08-10 15:09:10 -04:00
|
|
|
|
return provider.GetLineups(null, country, location);
|
2015-07-23 09:23:22 -04:00
|
|
|
|
}
|
2015-08-10 15:09:10 -04:00
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
var info = config.ListingProviders.FirstOrDefault(i => string.Equals(i.Id, providerId, StringComparison.OrdinalIgnoreCase));
|
2015-07-23 09:23:22 -04:00
|
|
|
|
|
2015-08-10 15:09:10 -04:00
|
|
|
|
var provider = _listingProviders.FirstOrDefault(i => string.Equals(info.Type, i.Type, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
|
|
|
|
|
if (provider == null)
|
|
|
|
|
{
|
|
|
|
|
throw new ResourceNotFoundException();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return provider.GetLineups(info, country, location);
|
|
|
|
|
}
|
2015-07-23 09:23:22 -04:00
|
|
|
|
}
|
2015-08-21 15:25:35 -04:00
|
|
|
|
|
|
|
|
|
public Task<MBRegistrationRecord> GetRegistrationInfo(string channelId, string programId, string feature)
|
|
|
|
|
{
|
|
|
|
|
ILiveTvService service;
|
|
|
|
|
|
|
|
|
|
if (string.IsNullOrWhiteSpace(programId))
|
|
|
|
|
{
|
|
|
|
|
var channel = GetInternalChannel(channelId);
|
|
|
|
|
service = GetService(channel);
|
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
var program = GetInternalProgram(programId);
|
|
|
|
|
service = GetService(program);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var hasRegistration = service as IHasRegistrationInfo;
|
|
|
|
|
|
|
|
|
|
if (hasRegistration != null)
|
|
|
|
|
{
|
|
|
|
|
return hasRegistration.GetRegistrationInfo(feature);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return Task.FromResult(new MBRegistrationRecord
|
|
|
|
|
{
|
|
|
|
|
IsValid = true,
|
|
|
|
|
IsRegistered = true
|
|
|
|
|
});
|
|
|
|
|
}
|
2013-09-26 11:48:14 -04:00
|
|
|
|
}
|
2015-09-21 12:26:05 -04:00
|
|
|
|
}
|