2013-11-24 15:51:45 -05:00
|
|
|
|
using MediaBrowser.Common.Extensions;
|
|
|
|
|
using MediaBrowser.Common.IO;
|
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-01-12 01:31:21 -05:00
|
|
|
|
using MediaBrowser.Controller.MediaInfo;
|
2013-11-24 15:51:45 -05:00
|
|
|
|
using MediaBrowser.Controller.Persistence;
|
2014-01-13 11:25:18 -05:00
|
|
|
|
using MediaBrowser.Controller.Sorting;
|
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;
|
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;
|
2013-11-24 15:51:45 -05:00
|
|
|
|
using System.IO;
|
|
|
|
|
using System.Linq;
|
|
|
|
|
using System.Threading;
|
|
|
|
|
using System.Threading.Tasks;
|
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 IFileSystem _fileSystem;
|
|
|
|
|
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-12 01:31:21 -05:00
|
|
|
|
private readonly IMediaEncoder _mediaEncoder;
|
2014-01-15 00:38:08 -05:00
|
|
|
|
private readonly ITaskManager _taskManager;
|
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-01-12 01:31:21 -05:00
|
|
|
|
private readonly ConcurrentDictionary<string, LiveStreamInfo> _openStreams =
|
|
|
|
|
new ConcurrentDictionary<string, LiveStreamInfo>();
|
|
|
|
|
|
2014-01-11 00:49:18 -05:00
|
|
|
|
private List<Guid> _channelIdList = new List<Guid>();
|
2013-12-22 12:16:24 -05:00
|
|
|
|
private Dictionary<Guid, LiveTvProgram> _programs = new Dictionary<Guid, LiveTvProgram>();
|
2013-11-25 15:39:23 -05:00
|
|
|
|
|
2014-01-15 10:18:31 -05:00
|
|
|
|
public LiveTvManager(IServerConfigurationManager config, IFileSystem fileSystem, ILogger logger, IItemRepository itemRepo, IImageProcessor imageProcessor, IUserDataManager userDataManager, IDtoService dtoService, IUserManager userManager, ILibraryManager libraryManager, IMediaEncoder mediaEncoder, ITaskManager taskManager)
|
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
|
|
|
|
_fileSystem = fileSystem;
|
|
|
|
|
_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-12 01:31:21 -05:00
|
|
|
|
_mediaEncoder = mediaEncoder;
|
2014-01-15 10:18:31 -05:00
|
|
|
|
_taskManager = taskManager;
|
2014-01-12 10:58:47 -05:00
|
|
|
|
_userDataManager = userDataManager;
|
2013-12-14 20:17:57 -05:00
|
|
|
|
|
2014-01-01 13:26:31 -05:00
|
|
|
|
_tvDtoService = new LiveTvDtoService(dtoService, userDataManager, imageProcessor, logger, _itemRepo);
|
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; }
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-04 15:55:42 -05:00
|
|
|
|
public ILiveTvService ActiveService { get; private set; }
|
|
|
|
|
|
2013-09-26 11:48:14 -04:00
|
|
|
|
/// <summary>
|
|
|
|
|
/// Adds the parts.
|
|
|
|
|
/// </summary>
|
|
|
|
|
/// <param name="services">The services.</param>
|
|
|
|
|
public void AddParts(IEnumerable<ILiveTvService> services)
|
|
|
|
|
{
|
|
|
|
|
_services.AddRange(services);
|
2013-12-04 15:55:42 -05:00
|
|
|
|
|
2014-01-15 00:38:08 -05:00
|
|
|
|
SetActiveService(_services.FirstOrDefault());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private void SetActiveService(ILiveTvService service)
|
|
|
|
|
{
|
|
|
|
|
if (ActiveService != null)
|
|
|
|
|
{
|
|
|
|
|
ActiveService.DataSourceChanged -= service_DataSourceChanged;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
ActiveService = service;
|
|
|
|
|
|
|
|
|
|
if (service != null)
|
|
|
|
|
{
|
|
|
|
|
service.DataSourceChanged += service_DataSourceChanged;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void service_DataSourceChanged(object sender, EventArgs e)
|
|
|
|
|
{
|
|
|
|
|
_taskManager.CancelIfRunningAndQueue<RefreshChannelsScheduledTask>();
|
2013-09-26 11:48:14 -04:00
|
|
|
|
}
|
|
|
|
|
|
2013-12-14 20:17:57 -05:00
|
|
|
|
public Task<QueryResult<ChannelInfoDto>> GetChannels(ChannelQuery query, CancellationToken cancellationToken)
|
2013-11-24 15:51:45 -05:00
|
|
|
|
{
|
2013-11-25 21:53:48 -05:00
|
|
|
|
var user = string.IsNullOrEmpty(query.UserId) ? null : _userManager.GetUserById(new Guid(query.UserId));
|
|
|
|
|
|
2014-01-11 00:49:18 -05:00
|
|
|
|
var channels = _channelIdList.Select(_libraryManager.GetItemById)
|
|
|
|
|
.Where(i => i != null)
|
|
|
|
|
.OfType<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
|
2014-01-02 23:58:22 -05:00
|
|
|
|
.Where(i => i.IsParentalAllowed(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-01-10 08:52:01 -05:00
|
|
|
|
channels = channels.OrderBy(i =>
|
2013-11-24 15:51:45 -05:00
|
|
|
|
{
|
|
|
|
|
double number = 0;
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
if (!string.IsNullOrEmpty(i.Number))
|
2013-11-24 15:51:45 -05:00
|
|
|
|
{
|
2014-01-23 13:05:41 -05:00
|
|
|
|
double.TryParse(i.Number, out number);
|
2013-11-24 15:51:45 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return number;
|
|
|
|
|
|
2014-01-10 08:52:01 -05:00
|
|
|
|
}).ThenBy(i => i.Name);
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var returnChannels = allEnumerable
|
2014-01-23 13:05:41 -05:00
|
|
|
|
.Select(i => _tvDtoService.GetChannelInfoDto(i, GetCurrentProgram(i.ExternalId), user))
|
2014-01-10 08:52:01 -05:00
|
|
|
|
.ToArray();
|
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
|
|
|
|
{
|
2013-11-25 21:53:48 -05:00
|
|
|
|
Items = returnChannels,
|
2014-01-10 08:52:01 -05:00
|
|
|
|
TotalRecordCount = allChannels.Count
|
2013-11-25 15:39:23 -05:00
|
|
|
|
};
|
2013-12-14 20:17:57 -05:00
|
|
|
|
|
|
|
|
|
return Task.FromResult(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
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public LiveTvProgram GetInternalProgram(string id)
|
|
|
|
|
{
|
|
|
|
|
var guid = new Guid(id);
|
|
|
|
|
|
|
|
|
|
LiveTvProgram obj = null;
|
|
|
|
|
|
|
|
|
|
_programs.TryGetValue(guid, out obj);
|
|
|
|
|
return obj;
|
2013-11-24 15:51:45 -05: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
|
|
|
|
{
|
|
|
|
|
var service = ActiveService;
|
|
|
|
|
|
|
|
|
|
var recordings = await service.GetRecordingsAsync(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
var recording = recordings.FirstOrDefault(i => _tvDtoService.GetInternalRecordingId(service.Name, i.Id) == new Guid(id));
|
|
|
|
|
|
|
|
|
|
return await GetRecording(recording, service.Name, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
}
|
2013-12-21 13:37:34 -05:00
|
|
|
|
|
2014-01-17 11:36:01 -05:00
|
|
|
|
private readonly SemaphoreSlim _liveStreamSemaphore = new SemaphoreSlim(1, 1);
|
|
|
|
|
|
2014-01-02 18:07:37 -05:00
|
|
|
|
public async Task<LiveStreamInfo> GetRecordingStream(string id, 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
|
|
|
|
|
2014-01-17 11:36:01 -05:00
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
var service = ActiveService;
|
2013-12-22 13:58:51 -05:00
|
|
|
|
|
2014-01-17 11:36:01 -05:00
|
|
|
|
var recordings = await service.GetRecordingsAsync(cancellationToken).ConfigureAwait(false);
|
2013-12-22 13:58:51 -05:00
|
|
|
|
|
2014-01-17 11:36:01 -05:00
|
|
|
|
var recording = recordings.First(i => _tvDtoService.GetInternalRecordingId(service.Name, i.Id) == new Guid(id));
|
2014-01-12 01:31:21 -05:00
|
|
|
|
|
2014-01-17 11:36:01 -05:00
|
|
|
|
var result = await service.GetRecordingStream(recording.Id, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(result.Id))
|
|
|
|
|
{
|
|
|
|
|
_openStreams.AddOrUpdate(result.Id, result, (key, info) => result);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
2014-01-18 23:25:01 -05:00
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting recording 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-22 13:58:51 -05:00
|
|
|
|
}
|
|
|
|
|
|
2014-01-02 18:07:37 -05:00
|
|
|
|
public async Task<LiveStreamInfo> GetChannelStream(string id, CancellationToken cancellationToken)
|
2013-12-29 13:53:56 -05:00
|
|
|
|
{
|
2014-01-17 11:36:01 -05:00
|
|
|
|
await _liveStreamSemaphore.WaitAsync(cancellationToken).ConfigureAwait(false);
|
2013-12-29 13:53:56 -05:00
|
|
|
|
|
2014-01-17 11:36:01 -05:00
|
|
|
|
try
|
|
|
|
|
{
|
|
|
|
|
var service = ActiveService;
|
|
|
|
|
|
|
|
|
|
var channel = GetInternalChannel(id);
|
2013-12-29 13:53:56 -05:00
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
_logger.Info("Opening channel stream from {0}, external channel Id: {1}", service.Name, channel.ExternalId);
|
2014-01-18 23:25:01 -05:00
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
var result = await service.GetChannelStream(channel.ExternalId, cancellationToken).ConfigureAwait(false);
|
2014-01-12 01:31:21 -05:00
|
|
|
|
|
2014-01-17 11:36:01 -05:00
|
|
|
|
if (!string.IsNullOrEmpty(result.Id))
|
|
|
|
|
{
|
|
|
|
|
_openStreams.AddOrUpdate(result.Id, result, (key, info) => result);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
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
|
|
|
|
}
|
|
|
|
|
|
2013-12-19 16:51:32 -05:00
|
|
|
|
private async Task<LiveTvChannel> GetChannel(ChannelInfo channelInfo, string serviceName, CancellationToken cancellationToken)
|
2013-11-24 15:51:45 -05:00
|
|
|
|
{
|
2014-01-12 11:55:38 -05:00
|
|
|
|
var path = Path.Combine(_config.ApplicationPaths.ItemsByNamePath, "channels", _fileSystem.GetValidFilename(channelInfo.Name));
|
2013-11-24 15:51:45 -05:00
|
|
|
|
|
|
|
|
|
var fileInfo = new DirectoryInfo(path);
|
|
|
|
|
|
|
|
|
|
var isNew = false;
|
|
|
|
|
|
|
|
|
|
if (!fileInfo.Exists)
|
|
|
|
|
{
|
|
|
|
|
Directory.CreateDirectory(path);
|
|
|
|
|
fileInfo = new DirectoryInfo(path);
|
|
|
|
|
|
|
|
|
|
if (!fileInfo.Exists)
|
|
|
|
|
{
|
|
|
|
|
throw new IOException("Path not created: " + path);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
isNew = true;
|
|
|
|
|
}
|
|
|
|
|
|
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
|
|
|
|
|
|
|
|
|
if (item == null)
|
|
|
|
|
{
|
2013-12-19 16:51:32 -05:00
|
|
|
|
item = new LiveTvChannel
|
2013-11-24 15:51:45 -05:00
|
|
|
|
{
|
|
|
|
|
Name = channelInfo.Name,
|
|
|
|
|
Id = id,
|
|
|
|
|
DateCreated = _fileSystem.GetCreationTimeUtc(fileInfo),
|
|
|
|
|
DateModified = _fileSystem.GetLastWriteTimeUtc(fileInfo),
|
2013-12-19 16:51:32 -05:00
|
|
|
|
Path = path
|
2013-11-24 15:51:45 -05:00
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
isNew = true;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
item.ChannelType = channelInfo.ChannelType;
|
|
|
|
|
item.ProviderImageUrl = channelInfo.ImageUrl;
|
|
|
|
|
item.HasProviderImage = channelInfo.HasImage;
|
|
|
|
|
item.ProviderImagePath = channelInfo.ImagePath;
|
|
|
|
|
item.ExternalId = channelInfo.Id;
|
2013-12-19 16:51:32 -05:00
|
|
|
|
item.ServiceName = serviceName;
|
2014-01-23 13:05:41 -05:00
|
|
|
|
item.Number = channelInfo.Number;
|
|
|
|
|
|
|
|
|
|
if (string.IsNullOrEmpty(item.Name))
|
|
|
|
|
{
|
|
|
|
|
item.Name = channelInfo.Name;
|
|
|
|
|
}
|
2013-12-19 16:51:32 -05:00
|
|
|
|
|
2013-11-24 15:51:45 -05:00
|
|
|
|
// Set this now so we don't cause additional file system access during provider executions
|
|
|
|
|
item.ResetResolveArgs(fileInfo);
|
|
|
|
|
|
|
|
|
|
await item.RefreshMetadata(cancellationToken, forceSave: isNew, resetResolveArgs: false);
|
|
|
|
|
|
|
|
|
|
return item;
|
|
|
|
|
}
|
2013-11-25 11:15:31 -05:00
|
|
|
|
|
2013-12-22 13:58:51 -05:00
|
|
|
|
private async Task<LiveTvProgram> GetProgram(ProgramInfo info, ChannelType channelType, string serviceName, CancellationToken cancellationToken)
|
2013-12-21 13:37:34 -05:00
|
|
|
|
{
|
|
|
|
|
var isNew = false;
|
|
|
|
|
|
|
|
|
|
var id = _tvDtoService.GetInternalProgramId(serviceName, info.Id);
|
|
|
|
|
|
|
|
|
|
var item = _itemRepo.RetrieveItem(id) as LiveTvProgram;
|
|
|
|
|
|
|
|
|
|
if (item == null)
|
|
|
|
|
{
|
|
|
|
|
item = new LiveTvProgram
|
|
|
|
|
{
|
|
|
|
|
Name = info.Name,
|
|
|
|
|
Id = id,
|
|
|
|
|
DateCreated = DateTime.UtcNow,
|
|
|
|
|
DateModified = DateTime.UtcNow
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
isNew = true;
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-22 13:58:51 -05:00
|
|
|
|
item.ChannelType = channelType;
|
2013-12-21 13:37:34 -05:00
|
|
|
|
item.ServiceName = serviceName;
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
item.Audio = info.Audio;
|
|
|
|
|
item.ExternalChannelId = info.ChannelId;
|
|
|
|
|
item.CommunityRating = info.CommunityRating;
|
|
|
|
|
item.EndDate = info.EndDate;
|
|
|
|
|
item.EpisodeTitle = info.EpisodeTitle;
|
|
|
|
|
item.ExternalId = info.Id;
|
|
|
|
|
item.Genres = info.Genres;
|
|
|
|
|
item.HasProviderImage = info.HasImage;
|
|
|
|
|
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;
|
|
|
|
|
item.OfficialRating = info.OfficialRating;
|
|
|
|
|
item.Overview = info.Overview;
|
|
|
|
|
item.PremiereDate = info.OriginalAirDate;
|
|
|
|
|
item.ProviderImagePath = info.ImagePath;
|
|
|
|
|
item.ProviderImageUrl = info.ImageUrl;
|
|
|
|
|
item.RunTimeTicks = (info.EndDate - info.StartDate).Ticks;
|
|
|
|
|
item.StartDate = info.StartDate;
|
|
|
|
|
|
2013-12-21 13:37:34 -05:00
|
|
|
|
await item.RefreshMetadata(cancellationToken, forceSave: isNew, resetResolveArgs: false);
|
|
|
|
|
|
|
|
|
|
return item;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-01 13:26:31 -05:00
|
|
|
|
private async Task<ILiveTvRecording> GetRecording(RecordingInfo info, string serviceName, CancellationToken cancellationToken)
|
2013-12-19 16:51:32 -05:00
|
|
|
|
{
|
|
|
|
|
var isNew = false;
|
|
|
|
|
|
|
|
|
|
var id = _tvDtoService.GetInternalRecordingId(serviceName, info.Id);
|
|
|
|
|
|
2014-01-01 13:26:31 -05:00
|
|
|
|
var item = _itemRepo.RetrieveItem(id) as ILiveTvRecording;
|
2013-12-19 16:51:32 -05:00
|
|
|
|
|
|
|
|
|
if (item == null)
|
|
|
|
|
{
|
2014-01-01 13:26:31 -05: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
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(info.Path))
|
|
|
|
|
{
|
|
|
|
|
item.Path = info.Path;
|
|
|
|
|
}
|
|
|
|
|
else if (!string.IsNullOrEmpty(info.Url))
|
|
|
|
|
{
|
|
|
|
|
item.Path = info.Url;
|
|
|
|
|
}
|
2013-12-19 16:51:32 -05:00
|
|
|
|
|
|
|
|
|
isNew = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
item.RecordingInfo = info;
|
|
|
|
|
item.ServiceName = serviceName;
|
|
|
|
|
|
|
|
|
|
await item.RefreshMetadata(cancellationToken, forceSave: isNew, resetResolveArgs: false);
|
|
|
|
|
|
2014-01-11 00:49:18 -05:00
|
|
|
|
_libraryManager.RegisterItem((BaseItem)item);
|
|
|
|
|
|
2013-12-19 16:51:32 -05:00
|
|
|
|
return item;
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-28 11:58:13 -05:00
|
|
|
|
private LiveTvChannel GetChannel(LiveTvProgram program)
|
|
|
|
|
{
|
2014-01-23 13:05:41 -05:00
|
|
|
|
var programChannelId = program.ExternalChannelId;
|
2013-12-28 11:58:13 -05:00
|
|
|
|
|
|
|
|
|
var internalProgramChannelId = _tvDtoService.GetInternalChannelId(program.ServiceName, programChannelId);
|
|
|
|
|
|
|
|
|
|
return GetInternalChannel(internalProgramChannelId);
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-21 13:37:34 -05:00
|
|
|
|
public async Task<ProgramInfoDto> GetProgram(string id, CancellationToken cancellationToken, User user = null)
|
2013-12-17 15:02:12 -05:00
|
|
|
|
{
|
2013-12-22 12:16:24 -05:00
|
|
|
|
var program = GetInternalProgram(id);
|
2013-12-21 13:37:34 -05:00
|
|
|
|
|
2013-12-28 11:58:13 -05:00
|
|
|
|
var channel = GetChannel(program);
|
|
|
|
|
|
2014-01-17 15:51:29 -05:00
|
|
|
|
var dto = _tvDtoService.GetProgramInfoDto(program, channel, user);
|
2013-12-21 13:37:34 -05:00
|
|
|
|
|
|
|
|
|
await AddRecordingInfo(new[] { dto }, 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
|
|
|
|
}
|
|
|
|
|
|
2013-12-21 13:37:34 -05:00
|
|
|
|
public async Task<QueryResult<ProgramInfoDto>> GetPrograms(ProgramQuery query, CancellationToken cancellationToken)
|
2013-11-25 11:15:31 -05:00
|
|
|
|
{
|
2013-12-22 12:16:24 -05:00
|
|
|
|
IEnumerable<LiveTvProgram> programs = _programs.Values;
|
2013-11-25 11:15:31 -05:00
|
|
|
|
|
2014-01-05 20:59:21 -05:00
|
|
|
|
if (query.MinEndDate.HasValue)
|
|
|
|
|
{
|
|
|
|
|
var val = query.MinEndDate.Value;
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
programs = programs.Where(i => i.EndDate.HasValue && i.EndDate.Value >= val);
|
2014-01-05 20:59:21 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (query.MinStartDate.HasValue)
|
|
|
|
|
{
|
|
|
|
|
var val = query.MinStartDate.Value;
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
programs = programs.Where(i => i.StartDate >= val);
|
2014-01-05 20:59:21 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (query.MaxEndDate.HasValue)
|
|
|
|
|
{
|
|
|
|
|
var val = query.MaxEndDate.Value;
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
programs = programs.Where(i => i.EndDate.HasValue && i.EndDate.Value <= val);
|
2014-01-05 20:59:21 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (query.MaxStartDate.HasValue)
|
|
|
|
|
{
|
|
|
|
|
var val = query.MaxStartDate.Value;
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
programs = programs.Where(i => i.StartDate <= val);
|
2014-01-05 20:59:21 -05:00
|
|
|
|
}
|
|
|
|
|
|
2013-11-25 11:15:31 -05:00
|
|
|
|
if (query.ChannelIdList.Length > 0)
|
|
|
|
|
{
|
|
|
|
|
var guids = query.ChannelIdList.Select(i => new Guid(i)).ToList();
|
2013-12-21 13:37:34 -05:00
|
|
|
|
var serviceName = ActiveService.Name;
|
|
|
|
|
|
|
|
|
|
programs = programs.Where(i =>
|
|
|
|
|
{
|
2014-01-23 13:05:41 -05:00
|
|
|
|
var programChannelId = i.ExternalChannelId;
|
2013-12-22 22:46:03 -05:00
|
|
|
|
|
|
|
|
|
var internalProgramChannelId = _tvDtoService.GetInternalChannelId(serviceName, programChannelId);
|
2013-11-25 11:15:31 -05:00
|
|
|
|
|
2013-12-21 13:37:34 -05:00
|
|
|
|
return guids.Contains(internalProgramChannelId);
|
|
|
|
|
});
|
2013-11-25 15:39:23 -05:00
|
|
|
|
}
|
|
|
|
|
|
2013-12-21 13:37:34 -05:00
|
|
|
|
var user = string.IsNullOrEmpty(query.UserId) ? null : _userManager.GetUserById(new Guid(query.UserId));
|
|
|
|
|
|
|
|
|
|
if (user != null)
|
|
|
|
|
{
|
2014-01-05 20:59:21 -05:00
|
|
|
|
// Avoid implicitly captured closure
|
|
|
|
|
var currentUser = user;
|
|
|
|
|
programs = programs.Where(i => i.IsParentalAllowed(currentUser));
|
2013-12-21 13:37:34 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var returnArray = programs
|
2013-12-28 11:58:13 -05:00
|
|
|
|
.Select(i =>
|
|
|
|
|
{
|
|
|
|
|
var channel = GetChannel(i);
|
|
|
|
|
|
2014-01-17 15:51:29 -05:00
|
|
|
|
return _tvDtoService.GetProgramInfoDto(i, channel, user);
|
2013-12-28 11:58:13 -05:00
|
|
|
|
})
|
2013-12-21 13:37:34 -05:00
|
|
|
|
.ToArray();
|
|
|
|
|
|
|
|
|
|
await AddRecordingInfo(returnArray, cancellationToken).ConfigureAwait(false);
|
2013-11-25 15:39:23 -05:00
|
|
|
|
|
2013-12-17 15:02:12 -05:00
|
|
|
|
var result = new QueryResult<ProgramInfoDto>
|
2013-11-26 16:36:11 -05:00
|
|
|
|
{
|
|
|
|
|
Items = returnArray,
|
|
|
|
|
TotalRecordCount = returnArray.Length
|
|
|
|
|
};
|
2013-12-17 15:02:12 -05:00
|
|
|
|
|
2013-12-21 13:37:34 -05:00
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-12 10:58:47 -05:00
|
|
|
|
public async Task<QueryResult<ProgramInfoDto>> GetRecommendedPrograms(RecommendedProgramQuery query, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
IEnumerable<LiveTvProgram> programs = _programs.Values;
|
|
|
|
|
|
|
|
|
|
var user = _userManager.GetUserById(new Guid(query.UserId));
|
|
|
|
|
|
|
|
|
|
// Avoid implicitly captured closure
|
|
|
|
|
var currentUser = user;
|
|
|
|
|
programs = programs.Where(i => i.IsParentalAllowed(currentUser));
|
|
|
|
|
|
|
|
|
|
if (query.IsAiring.HasValue)
|
|
|
|
|
{
|
|
|
|
|
var val = query.IsAiring.Value;
|
|
|
|
|
programs = programs.Where(i => i.IsAiring == val);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (query.HasAired.HasValue)
|
|
|
|
|
{
|
|
|
|
|
var val = query.HasAired.Value;
|
|
|
|
|
programs = programs.Where(i => i.HasAired == val);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var serviceName = ActiveService.Name;
|
|
|
|
|
|
|
|
|
|
var programList = programs.ToList();
|
|
|
|
|
|
|
|
|
|
var genres = programList.SelectMany(i => i.Genres)
|
|
|
|
|
.Distinct(StringComparer.OrdinalIgnoreCase)
|
|
|
|
|
.Select(i => _libraryManager.GetGenre(i))
|
|
|
|
|
.ToDictionary(i => i.Name, StringComparer.OrdinalIgnoreCase);
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
programs = programList.OrderByDescending(i => GetRecommendationScore(i, user.Id, serviceName, genres))
|
|
|
|
|
.ThenBy(i => i.StartDate);
|
2014-01-12 10:58:47 -05:00
|
|
|
|
|
|
|
|
|
if (query.Limit.HasValue)
|
|
|
|
|
{
|
|
|
|
|
programs = programs.Take(query.Limit.Value)
|
2014-01-23 13:05:41 -05:00
|
|
|
|
.OrderBy(i => i.StartDate);
|
2014-01-12 10:58:47 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var returnArray = programs
|
|
|
|
|
.Select(i =>
|
|
|
|
|
{
|
|
|
|
|
var channel = GetChannel(i);
|
|
|
|
|
|
2014-01-17 15:51:29 -05:00
|
|
|
|
return _tvDtoService.GetProgramInfoDto(i, channel, user);
|
2014-01-12 10:58:47 -05:00
|
|
|
|
})
|
|
|
|
|
.ToArray();
|
|
|
|
|
|
|
|
|
|
await AddRecordingInfo(returnArray, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
var result = new QueryResult<ProgramInfoDto>
|
|
|
|
|
{
|
|
|
|
|
Items = returnArray,
|
|
|
|
|
TotalRecordCount = returnArray.Length
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
private int GetRecommendationScore(LiveTvProgram program, Guid userId, string serviceName, 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++;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
var internalChannelId = _tvDtoService.GetInternalChannelId(serviceName, program.ExternalChannelId);
|
2014-01-12 10:58:47 -05:00
|
|
|
|
var channel = GetInternalChannel(internalChannelId);
|
|
|
|
|
|
|
|
|
|
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();
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-21 13:37:34 -05:00
|
|
|
|
private async Task AddRecordingInfo(IEnumerable<ProgramInfoDto> programs, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var timers = await ActiveService.GetTimersAsync(cancellationToken).ConfigureAwait(false);
|
|
|
|
|
var timerList = timers.ToList();
|
|
|
|
|
|
|
|
|
|
foreach (var program in programs)
|
|
|
|
|
{
|
|
|
|
|
var timer = timerList.FirstOrDefault(i => string.Equals(i.ProgramId, program.ExternalId, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
|
|
|
|
|
if (timer != null)
|
|
|
|
|
{
|
|
|
|
|
program.TimerId = _tvDtoService.GetInternalTimerId(program.ServiceName, timer.Id)
|
|
|
|
|
.ToString("N");
|
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(timer.SeriesTimerId))
|
|
|
|
|
{
|
|
|
|
|
program.SeriesTimerId = _tvDtoService.GetInternalSeriesTimerId(program.ServiceName, timer.SeriesTimerId)
|
|
|
|
|
.ToString("N");
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-25 16:53:06 -05:00
|
|
|
|
}
|
|
|
|
|
|
2013-11-26 16:36:11 -05:00
|
|
|
|
internal async Task RefreshChannels(IProgress<double> progress, CancellationToken cancellationToken)
|
2013-11-25 16:53:06 -05:00
|
|
|
|
{
|
|
|
|
|
// Avoid implicitly captured closure
|
2013-12-05 11:50:21 -05:00
|
|
|
|
var service = ActiveService;
|
2013-11-25 16:53:06 -05:00
|
|
|
|
|
2013-12-05 11:50:21 -05:00
|
|
|
|
if (service == null)
|
|
|
|
|
{
|
|
|
|
|
progress.Report(100);
|
|
|
|
|
return;
|
|
|
|
|
}
|
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;
|
|
|
|
|
|
2013-12-05 11:50:21 -05:00
|
|
|
|
foreach (var channelInfo in allChannelsList)
|
2013-11-25 16:53:06 -05:00
|
|
|
|
{
|
|
|
|
|
try
|
|
|
|
|
{
|
2013-11-26 16:36:11 -05:00
|
|
|
|
var item = await GetChannel(channelInfo.Item2, channelInfo.Item1, 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
|
|
|
|
|
|
|
|
|
_channelIdList = list.Select(i => i.Id).ToList();
|
2014-01-02 23:58:22 -05:00
|
|
|
|
progress.Report(15);
|
|
|
|
|
|
2014-01-11 18:07:56 -05:00
|
|
|
|
numComplete = 0;
|
|
|
|
|
var programs = new List<LiveTvProgram>();
|
2014-01-02 23:58:22 -05:00
|
|
|
|
|
2014-01-12 11:55:38 -05:00
|
|
|
|
var guideDays = GetGuideDays(list.Count);
|
|
|
|
|
|
2014-01-02 23:58:22 -05:00
|
|
|
|
foreach (var item in list)
|
|
|
|
|
{
|
|
|
|
|
// Avoid implicitly captured closure
|
|
|
|
|
var currentChannel = item;
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
var programTasks = channelPrograms.Select(program => GetProgram(program, currentChannel.ChannelType, service.Name, cancellationToken));
|
2013-12-21 13:37:34 -05:00
|
|
|
|
var programEntities = await Task.WhenAll(programTasks).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
programs.AddRange(programEntities);
|
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
|
|
|
|
|
|
|
|
|
progress.Report(90 * percent + 10);
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-22 12:16:24 -05:00
|
|
|
|
_programs = programs.ToDictionary(i => i.Id);
|
2013-11-25 16:53:06 -05:00
|
|
|
|
}
|
|
|
|
|
|
2014-01-12 11:55:38 -05:00
|
|
|
|
private double GetGuideDays(int channelCount)
|
|
|
|
|
{
|
|
|
|
|
if (_config.Configuration.LiveTvOptions.GuideDays.HasValue)
|
|
|
|
|
{
|
|
|
|
|
return _config.Configuration.LiveTvOptions.GuideDays.Value;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
|
|
// No less than 2, no more than 14
|
|
|
|
|
return Math.Max(2, Math.Min(days, 14));
|
|
|
|
|
}
|
|
|
|
|
|
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
|
|
|
|
}
|
|
|
|
|
|
2013-11-26 16:36:11 -05:00
|
|
|
|
public async Task<QueryResult<RecordingInfoDto>> GetRecordings(RecordingQuery query, CancellationToken cancellationToken)
|
2013-11-25 21:53:48 -05:00
|
|
|
|
{
|
2013-12-19 16:51:32 -05:00
|
|
|
|
var service = ActiveService;
|
2013-12-14 20:17:57 -05:00
|
|
|
|
|
2013-12-19 16:51:32 -05:00
|
|
|
|
var user = string.IsNullOrEmpty(query.UserId) ? null : _userManager.GetUserById(new Guid(query.UserId));
|
2013-11-26 16:36:11 -05:00
|
|
|
|
|
2013-12-19 16:51:32 -05:00
|
|
|
|
var recordings = await service.GetRecordingsAsync(cancellationToken).ConfigureAwait(false);
|
2013-11-26 16:36:11 -05:00
|
|
|
|
|
2013-12-19 16:51:32 -05:00
|
|
|
|
if (!string.IsNullOrEmpty(query.ChannelId))
|
|
|
|
|
{
|
2013-12-28 16:37:01 -05:00
|
|
|
|
var guid = new Guid(query.ChannelId);
|
|
|
|
|
|
|
|
|
|
var currentServiceName = service.Name;
|
|
|
|
|
|
2014-01-01 13:26:31 -05:00
|
|
|
|
recordings = recordings
|
|
|
|
|
.Where(i => _tvDtoService.GetInternalChannelId(currentServiceName, i.ChannelId) == guid);
|
2013-11-26 16:36:11 -05:00
|
|
|
|
}
|
|
|
|
|
|
2013-12-19 16:51:32 -05:00
|
|
|
|
if (!string.IsNullOrEmpty(query.Id))
|
2013-11-26 16:36:11 -05:00
|
|
|
|
{
|
2013-12-28 16:37:01 -05:00
|
|
|
|
var guid = new Guid(query.Id);
|
|
|
|
|
|
|
|
|
|
var currentServiceName = service.Name;
|
2013-12-28 18:09:24 -05:00
|
|
|
|
|
2014-01-01 13:26:31 -05:00
|
|
|
|
recordings = recordings
|
|
|
|
|
.Where(i => _tvDtoService.GetInternalRecordingId(currentServiceName, i.Id) == guid);
|
2013-12-28 16:37:01 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(query.GroupId))
|
|
|
|
|
{
|
|
|
|
|
var guid = new Guid(query.GroupId);
|
|
|
|
|
|
2014-01-01 13:26:31 -05:00
|
|
|
|
recordings = recordings.Where(i => GetRecordingGroupIds(i).Contains(guid));
|
|
|
|
|
}
|
|
|
|
|
|
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;
|
2014-01-01 13:26:31 -05: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;
|
|
|
|
|
recordings = recordings.Where(i => (i.Status == val));
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-08 00:25:21 -05:00
|
|
|
|
if (!string.IsNullOrEmpty(query.SeriesTimerId))
|
|
|
|
|
{
|
|
|
|
|
var guid = new Guid(query.SeriesTimerId);
|
|
|
|
|
|
|
|
|
|
var currentServiceName = service.Name;
|
|
|
|
|
|
|
|
|
|
recordings = recordings
|
|
|
|
|
.Where(i => _tvDtoService.GetInternalSeriesTimerId(currentServiceName, i.SeriesTimerId) == guid);
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-10 08:52:01 -05:00
|
|
|
|
recordings = recordings.OrderByDescending(i => i.StartDate);
|
2013-12-28 18:09:24 -05:00
|
|
|
|
|
2014-01-10 08:52:01 -05:00
|
|
|
|
IEnumerable<ILiveTvRecording> entities = await GetEntities(recordings, service.Name, cancellationToken).ConfigureAwait(false);
|
2013-12-19 16:51:32 -05:00
|
|
|
|
|
2013-12-21 13:37:34 -05:00
|
|
|
|
if (user != null)
|
|
|
|
|
{
|
2013-12-28 18:09:24 -05:00
|
|
|
|
var currentUser = user;
|
2014-01-01 13:26:31 -05:00
|
|
|
|
entities = entities.Where(i => i.IsParentalAllowed(currentUser));
|
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
|
|
|
|
}
|
|
|
|
|
|
2013-12-19 16:51:32 -05:00
|
|
|
|
var returnArray = entities
|
2013-12-22 22:46:03 -05:00
|
|
|
|
.Select(i =>
|
|
|
|
|
{
|
2013-12-28 11:58:13 -05:00
|
|
|
|
var channel = string.IsNullOrEmpty(i.RecordingInfo.ChannelId) ? null : GetInternalChannel(_tvDtoService.GetInternalChannelId(service.Name, i.RecordingInfo.ChannelId));
|
2013-12-22 22:46:03 -05:00
|
|
|
|
return _tvDtoService.GetRecordingInfoDto(i, channel, service, user);
|
|
|
|
|
})
|
2013-11-27 14:04:19 -05:00
|
|
|
|
.ToArray();
|
2013-11-25 21:53:48 -05:00
|
|
|
|
|
|
|
|
|
return new QueryResult<RecordingInfoDto>
|
|
|
|
|
{
|
|
|
|
|
Items = returnArray,
|
|
|
|
|
TotalRecordCount = returnArray.Length
|
|
|
|
|
};
|
|
|
|
|
}
|
2013-11-26 16:36:11 -05:00
|
|
|
|
|
2014-01-01 13:26:31 -05:00
|
|
|
|
private Task<ILiveTvRecording[]> GetEntities(IEnumerable<RecordingInfo> recordings, string serviceName, CancellationToken cancellationToken)
|
2013-12-19 16:51:32 -05:00
|
|
|
|
{
|
|
|
|
|
var tasks = recordings.Select(i => GetRecording(i, serviceName, cancellationToken));
|
|
|
|
|
|
|
|
|
|
return Task.WhenAll(tasks);
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-26 16:36:11 -05:00
|
|
|
|
private IEnumerable<ILiveTvService> GetServices(string serviceName, string channelId)
|
|
|
|
|
{
|
|
|
|
|
IEnumerable<ILiveTvService> services = _services;
|
|
|
|
|
|
|
|
|
|
if (string.IsNullOrEmpty(serviceName) && !string.IsNullOrEmpty(channelId))
|
|
|
|
|
{
|
2013-12-22 12:16:24 -05:00
|
|
|
|
var channel = GetInternalChannel(channelId);
|
2013-11-26 16:36:11 -05:00
|
|
|
|
|
2013-12-22 12:16:24 -05:00
|
|
|
|
if (channel != null)
|
|
|
|
|
{
|
|
|
|
|
serviceName = channel.ServiceName;
|
|
|
|
|
}
|
2013-11-26 16:36:11 -05:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(serviceName))
|
|
|
|
|
{
|
|
|
|
|
services = services.Where(i => string.Equals(i.Name, serviceName, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return services;
|
|
|
|
|
}
|
|
|
|
|
|
2013-11-27 14:04:19 -05:00
|
|
|
|
public async Task<QueryResult<TimerInfoDto>> GetTimers(TimerQuery query, CancellationToken cancellationToken)
|
|
|
|
|
{
|
2013-12-22 12:16:24 -05:00
|
|
|
|
var service = ActiveService;
|
|
|
|
|
var timers = await service.GetTimersAsync(cancellationToken).ConfigureAwait(false);
|
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);
|
2013-12-22 22:46:03 -05:00
|
|
|
|
timers = timers.Where(i => guid == _tvDtoService.GetInternalChannelId(service.Name, i.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);
|
|
|
|
|
|
|
|
|
|
var currentServiceName = service.Name;
|
|
|
|
|
|
|
|
|
|
timers = timers
|
|
|
|
|
.Where(i => _tvDtoService.GetInternalSeriesTimerId(currentServiceName, i.SeriesTimerId) == guid);
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-22 12:16:24 -05:00
|
|
|
|
var returnArray = timers
|
|
|
|
|
.Select(i =>
|
|
|
|
|
{
|
|
|
|
|
var program = string.IsNullOrEmpty(i.ProgramId) ? null : GetInternalProgram(_tvDtoService.GetInternalProgramId(service.Name, i.ProgramId).ToString("N"));
|
2013-12-28 11:58:13 -05:00
|
|
|
|
var channel = string.IsNullOrEmpty(i.ChannelId) ? null : GetInternalChannel(_tvDtoService.GetInternalChannelId(service.Name, i.ChannelId));
|
2013-12-22 12:16:24 -05:00
|
|
|
|
|
2013-12-22 22:46:03 -05:00
|
|
|
|
return _tvDtoService.GetTimerInfoDto(i, service, program, channel);
|
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)
|
|
|
|
|
{
|
2013-12-15 09:19:24 -05:00
|
|
|
|
var recording = await GetRecording(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));
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-15 09:19:24 -05:00
|
|
|
|
var service = GetServices(recording.ServiceName, null)
|
2013-11-29 11:58:24 -05:00
|
|
|
|
.First();
|
|
|
|
|
|
|
|
|
|
await service.DeleteRecordingAsync(recording.ExternalId, CancellationToken.None).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
2013-12-15 09:19:24 -05:00
|
|
|
|
var service = GetServices(timer.ServiceName, null)
|
|
|
|
|
.First();
|
|
|
|
|
|
|
|
|
|
await service.CancelTimerAsync(timer.ExternalId, CancellationToken.None).ConfigureAwait(false);
|
|
|
|
|
}
|
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));
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-15 09:19:24 -05:00
|
|
|
|
var service = GetServices(timer.ServiceName, null)
|
2013-11-29 11:58:24 -05:00
|
|
|
|
.First();
|
|
|
|
|
|
2013-12-15 09:19:24 -05:00
|
|
|
|
await service.CancelSeriesTimerAsync(timer.ExternalId, CancellationToken.None).ConfigureAwait(false);
|
2013-11-29 11:58:24 -05:00
|
|
|
|
}
|
2013-12-03 23:18:50 -05:00
|
|
|
|
|
2013-12-14 20:17:57 -05:00
|
|
|
|
public async Task<RecordingInfoDto> GetRecording(string id, CancellationToken cancellationToken, User user = null)
|
2013-12-03 23:18:50 -05:00
|
|
|
|
{
|
2013-12-14 20:17:57 -05:00
|
|
|
|
var results = await GetRecordings(new RecordingQuery
|
|
|
|
|
{
|
2013-12-19 16:51:32 -05:00
|
|
|
|
UserId = user == null ? null : user.Id.ToString("N"),
|
|
|
|
|
Id = id
|
2013-12-14 20:17:57 -05:00
|
|
|
|
|
|
|
|
|
}, cancellationToken).ConfigureAwait(false);
|
2013-12-03 23:18:50 -05:00
|
|
|
|
|
2013-12-19 16:51:32 -05:00
|
|
|
|
return results.Items.FirstOrDefault();
|
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);
|
|
|
|
|
|
|
|
|
|
return results.Items.FirstOrDefault(i => string.Equals(i.Id, id, StringComparison.CurrentCulture));
|
|
|
|
|
}
|
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);
|
|
|
|
|
|
|
|
|
|
return results.Items.FirstOrDefault(i => string.Equals(i.Id, id, StringComparison.CurrentCulture));
|
|
|
|
|
}
|
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)
|
|
|
|
|
{
|
2013-12-22 13:58:51 -05:00
|
|
|
|
var service = ActiveService;
|
2013-12-14 20:17:57 -05:00
|
|
|
|
|
2013-12-22 13:58:51 -05:00
|
|
|
|
var timers = await service.GetSeriesTimersAsync(cancellationToken).ConfigureAwait(false);
|
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 ?
|
2014-01-13 11:25:18 -05:00
|
|
|
|
timers.OrderBy(i => i.Priority).ThenByStringDescending(i => i.Name) :
|
|
|
|
|
timers.OrderByDescending(i => i.Priority).ThenByString(i => i.Name);
|
2014-01-11 18:07:56 -05:00
|
|
|
|
}
|
|
|
|
|
else
|
|
|
|
|
{
|
|
|
|
|
timers = query.SortOrder == SortOrder.Descending ?
|
2014-01-13 11:25:18 -05:00
|
|
|
|
timers.OrderByStringDescending(i => i.Name) :
|
|
|
|
|
timers.OrderByString(i => i.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;
|
|
|
|
|
|
|
|
|
|
if (!string.IsNullOrEmpty(i.ChannelId))
|
|
|
|
|
{
|
|
|
|
|
var internalChannelId = _tvDtoService.GetInternalChannelId(service.Name, i.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
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return _tvDtoService.GetSeriesTimerInfoDto(i, service, channelName);
|
|
|
|
|
|
|
|
|
|
})
|
2013-12-14 20:17:57 -05:00
|
|
|
|
.ToArray();
|
|
|
|
|
|
|
|
|
|
return new QueryResult<SeriesTimerInfoDto>
|
|
|
|
|
{
|
|
|
|
|
Items = returnArray,
|
|
|
|
|
TotalRecordCount = returnArray.Length
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2013-12-21 13:37:34 -05:00
|
|
|
|
public 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
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
var dto = _tvDtoService.GetChannelInfoDto(channel, GetCurrentProgram(channel.ExternalId), user);
|
2013-12-14 20:17:57 -05:00
|
|
|
|
|
2013-12-21 13:37:34 -05:00
|
|
|
|
return Task.FromResult(dto);
|
2013-12-14 20:17:57 -05:00
|
|
|
|
}
|
2013-12-17 15:02:12 -05:00
|
|
|
|
|
2014-01-02 16:21:06 -05:00
|
|
|
|
private LiveTvProgram GetCurrentProgram(string externalChannelId)
|
|
|
|
|
{
|
|
|
|
|
var now = DateTime.UtcNow;
|
|
|
|
|
|
|
|
|
|
return _programs.Values
|
2014-01-23 13:05:41 -05:00
|
|
|
|
.Where(i => string.Equals(externalChannelId, i.ExternalChannelId, StringComparison.OrdinalIgnoreCase))
|
|
|
|
|
.OrderBy(i => i.StartDate)
|
|
|
|
|
.SkipWhile(i => now >= (i.EndDate ?? DateTime.MinValue))
|
2014-01-02 16:21:06 -05:00
|
|
|
|
.FirstOrDefault();
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
private async Task<SeriesTimerInfo> GetNewTimerDefaultsInternal(CancellationToken cancellationToken, LiveTvProgram program = null)
|
2013-12-17 15:02:12 -05:00
|
|
|
|
{
|
2014-01-23 13:05:41 -05:00
|
|
|
|
ProgramInfo programInfo = null;
|
|
|
|
|
|
|
|
|
|
if (program != null)
|
|
|
|
|
{
|
|
|
|
|
programInfo = new ProgramInfo
|
|
|
|
|
{
|
|
|
|
|
Audio = program.Audio,
|
|
|
|
|
ChannelId = program.ExternalChannelId,
|
|
|
|
|
CommunityRating = program.CommunityRating,
|
|
|
|
|
EndDate = program.EndDate ?? DateTime.MinValue,
|
|
|
|
|
EpisodeTitle = program.EpisodeTitle,
|
|
|
|
|
Genres = program.Genres,
|
|
|
|
|
HasImage = program.HasProviderImage,
|
|
|
|
|
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,
|
|
|
|
|
ImagePath = program.ProviderImagePath,
|
|
|
|
|
ImageUrl = program.ProviderImageUrl,
|
|
|
|
|
Name = program.Name,
|
|
|
|
|
OfficialRating = program.OfficialRating
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var info = await ActiveService.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
|
|
|
|
|
2014-01-13 15:31:09 -05:00
|
|
|
|
return info;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task<SeriesTimerInfoDto> GetNewTimerDefaults(CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var info = await GetNewTimerDefaultsInternal(cancellationToken).ConfigureAwait(false);
|
2013-12-18 00:44:46 -05:00
|
|
|
|
|
2014-01-13 15:31:09 -05:00
|
|
|
|
var obj = _tvDtoService.GetSeriesTimerInfoDto(info, ActiveService, null);
|
2013-12-18 00:44:46 -05:00
|
|
|
|
|
|
|
|
|
return obj;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task<SeriesTimerInfoDto> GetNewTimerDefaults(string programId, CancellationToken cancellationToken)
|
|
|
|
|
{
|
2014-01-23 13:05:41 -05: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);
|
|
|
|
|
var info = _tvDtoService.GetSeriesTimerInfoDto(defaults, ActiveService, 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;
|
2014-01-13 15:31:09 -05:00
|
|
|
|
info.ExternalProgramId = programDto.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)
|
|
|
|
|
{
|
|
|
|
|
var service = string.IsNullOrEmpty(timer.ServiceName) ? ActiveService : GetServices(timer.ServiceName, null).First();
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task CreateSeriesTimer(SeriesTimerInfoDto timer, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var service = string.IsNullOrEmpty(timer.ServiceName) ? ActiveService : GetServices(timer.ServiceName, null).First();
|
|
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task UpdateTimer(TimerInfoDto timer, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var info = await _tvDtoService.GetTimerInfo(timer, false, this, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
var service = string.IsNullOrEmpty(timer.ServiceName) ? ActiveService : GetServices(timer.ServiceName, null).First();
|
|
|
|
|
|
|
|
|
|
await service.UpdateTimerAsync(info, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task UpdateSeriesTimer(SeriesTimerInfoDto timer, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var info = await _tvDtoService.GetSeriesTimerInfo(timer, false, this, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
var service = string.IsNullOrEmpty(timer.ServiceName) ? ActiveService : GetServices(timer.ServiceName, null).First();
|
|
|
|
|
|
|
|
|
|
await service.UpdateSeriesTimerAsync(info, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
}
|
2013-12-28 16:37:01 -05:00
|
|
|
|
|
2014-01-16 12:23:30 -05:00
|
|
|
|
private IEnumerable<string> GetRecordingGroupNames(RecordingInfo 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
|
|
|
|
|
2013-12-28 16:37:01 -05:00
|
|
|
|
private List<Guid> GetRecordingGroupIds(RecordingInfo recording)
|
|
|
|
|
{
|
|
|
|
|
return GetRecordingGroupNames(recording).Select(i => i.ToLower()
|
|
|
|
|
.GetMD5())
|
|
|
|
|
.ToList();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public async Task<QueryResult<RecordingGroupDto>> GetRecordingGroups(RecordingGroupQuery query, CancellationToken cancellationToken)
|
|
|
|
|
{
|
|
|
|
|
var recordingResult = await GetRecordings(new RecordingQuery
|
|
|
|
|
{
|
|
|
|
|
UserId = query.UserId
|
|
|
|
|
|
|
|
|
|
}, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
|
|
|
|
|
var recordings = recordingResult.Items;
|
|
|
|
|
|
|
|
|
|
var groups = new List<RecordingGroupDto>();
|
|
|
|
|
|
|
|
|
|
var series = recordings
|
|
|
|
|
.Where(i => i.IsSeries)
|
|
|
|
|
.ToLookup(i => i.Name, StringComparer.OrdinalIgnoreCase)
|
|
|
|
|
.ToList();
|
|
|
|
|
|
2014-01-13 11:25:18 -05:00
|
|
|
|
groups.AddRange(series.OrderByString(i => i.Key).Select(i => new RecordingGroupDto
|
2013-12-28 16:37:01 -05:00
|
|
|
|
{
|
|
|
|
|
Name = i.Key,
|
|
|
|
|
RecordingCount = i.Count()
|
|
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
groups.Add(new RecordingGroupDto
|
|
|
|
|
{
|
|
|
|
|
Name = "Kids",
|
|
|
|
|
RecordingCount = recordings.Count(i => i.IsKids)
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
groups.Add(new RecordingGroupDto
|
|
|
|
|
{
|
|
|
|
|
Name = "Movies",
|
|
|
|
|
RecordingCount = recordings.Count(i => i.IsMovie)
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
groups.Add(new RecordingGroupDto
|
|
|
|
|
{
|
|
|
|
|
Name = "News",
|
|
|
|
|
RecordingCount = recordings.Count(i => i.IsNews)
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
groups.Add(new RecordingGroupDto
|
|
|
|
|
{
|
|
|
|
|
Name = "Sports",
|
|
|
|
|
RecordingCount = recordings.Count(i => i.IsSports)
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
groups.Add(new RecordingGroupDto
|
|
|
|
|
{
|
|
|
|
|
Name = "Others",
|
|
|
|
|
RecordingCount = recordings.Count(i => !i.IsSports && !i.IsNews && !i.IsMovie && !i.IsKids && !i.IsSeries)
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
groups = groups
|
|
|
|
|
.Where(i => i.RecordingCount > 0)
|
|
|
|
|
.ToList();
|
|
|
|
|
|
|
|
|
|
foreach (var group in groups)
|
|
|
|
|
{
|
|
|
|
|
group.Id = group.Name.ToLower().GetMD5().ToString("N");
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return new QueryResult<RecordingGroupDto>
|
|
|
|
|
{
|
|
|
|
|
Items = groups.ToArray(),
|
|
|
|
|
TotalRecordCount = groups.Count
|
|
|
|
|
};
|
|
|
|
|
}
|
2014-01-05 01:50:48 -05:00
|
|
|
|
|
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);
|
|
|
|
|
|
2014-01-18 23:25:01 -05:00
|
|
|
|
var service = ActiveService;
|
|
|
|
|
|
|
|
|
|
_logger.Info("Closing live stream from {0}, stream Id: {1}", service.Name, id);
|
|
|
|
|
|
2014-01-17 11:36:01 -05:00
|
|
|
|
try
|
|
|
|
|
{
|
2014-01-18 23:25:01 -05:00
|
|
|
|
await service.CloseLiveStream(id, cancellationToken).ConfigureAwait(false);
|
|
|
|
|
}
|
|
|
|
|
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()
|
|
|
|
|
{
|
|
|
|
|
var programs = _programs.ToList();
|
|
|
|
|
|
2014-01-23 13:05:41 -05:00
|
|
|
|
var startDate = programs.Select(i => i.Value.StartDate).Min();
|
|
|
|
|
var endDate = programs.Select(i => i.Value.StartDate).Max();
|
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())
|
|
|
|
|
{
|
|
|
|
|
var task = CloseLiveStream(stream.Id, CancellationToken.None);
|
|
|
|
|
|
|
|
|
|
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
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
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;
|
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;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return _tvDtoService.GetTunerInfoDto(service.Name, i, channelName);
|
|
|
|
|
|
|
|
|
|
}).ToList();
|
2014-01-16 12:23:30 -05:00
|
|
|
|
}
|
|
|
|
|
catch (Exception ex)
|
|
|
|
|
{
|
|
|
|
|
_logger.ErrorException("Error getting service status info from {0}", ex, service.Name);
|
|
|
|
|
|
|
|
|
|
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 activeServiceInfo = ActiveService == null ? null :
|
|
|
|
|
servicesList.FirstOrDefault(i => string.Equals(i.Name, ActiveService.Name, StringComparison.OrdinalIgnoreCase));
|
|
|
|
|
|
|
|
|
|
var info = new LiveTvInfo
|
|
|
|
|
{
|
|
|
|
|
Services = servicesList.ToList(),
|
|
|
|
|
ActiveServiceName = activeServiceInfo == null ? null : activeServiceInfo.Name,
|
|
|
|
|
IsEnabled = ActiveService != null,
|
|
|
|
|
Status = activeServiceInfo == null ? LiveTvServiceStatus.Unavailable : activeServiceInfo.Status,
|
|
|
|
|
StatusMessage = activeServiceInfo == null ? null : activeServiceInfo.StatusMessage
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
info.EnabledUsers = _userManager.Users
|
|
|
|
|
.Where(i => i.Configuration.EnableLiveTvAccess && info.IsEnabled)
|
|
|
|
|
.Select(i => i.Id.ToString("N"))
|
|
|
|
|
.ToList();
|
|
|
|
|
|
|
|
|
|
return info;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <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)
|
|
|
|
|
{
|
|
|
|
|
return ActiveService.ResetTuner(id, cancellationToken);
|
|
|
|
|
}
|
2013-09-26 11:48:14 -04:00
|
|
|
|
}
|
|
|
|
|
}
|