public static List<TimerInfo> GetTimersForSeries(SeriesTimerInfo seriesTimer, IEnumerable<ProgramInfo> epgData, IReadOnlyList<RecordingInfo> currentRecordings, ILogger logger) { List<TimerInfo> timers = new List<TimerInfo>(); // Filtered Per Show var filteredEpg = epgData.Where(epg => epg.Id.Substring(0, 10) == seriesTimer.Id); if (!seriesTimer.RecordAnyTime) { filteredEpg = filteredEpg.Where(epg => (seriesTimer.StartDate.TimeOfDay == epg.StartDate.TimeOfDay)); } if (seriesTimer.RecordNewOnly) { filteredEpg = filteredEpg.Where(epg => !epg.IsRepeat); //Filtered by New only } if (!seriesTimer.RecordAnyChannel) { filteredEpg = filteredEpg.Where(epg => string.Equals(epg.ChannelId, seriesTimer.ChannelId, StringComparison.OrdinalIgnoreCase)); } filteredEpg = filteredEpg.Where(epg => seriesTimer.Days.Contains(epg.StartDate.DayOfWeek)); filteredEpg = filteredEpg.Where(epg => currentRecordings.All(r => r.Id.Substring(0, 14) != epg.Id.Substring(0, 14))); //filtered recordings already running filteredEpg = filteredEpg.GroupBy(epg => epg.Id.Substring(0, 14)).Select(g => g.First()).ToList(); foreach (var epg in filteredEpg) { timers.Add(CreateTimer(epg, seriesTimer)); } return timers; }
public static List<SeriesTimerInfo> GetSeriesTimers(Stream stream, IJsonSerializer json, ILogger logger) { List<SeriesTimerInfo> ret = new List<SeriesTimerInfo>(); var root = ParseRecRules(stream, json); foreach (var item in root.RecRuleList.RecRules) { if (!item.Inactive && string.Compare(item.Type, "Single Record", true) != 0 && string.Compare(item.Type, "Not Recording", true) != 0) { SeriesTimerInfo val = new SeriesTimerInfo() { Name = item.Title, //Overview = item.Description, ChannelId = item.ChanId.ToString(), EndDate = (DateTime)item.EndTime, StartDate = (DateTime)item.StartTime, //Overview = item.Description, Id = item.Id, PrePaddingSeconds = item.StartOffset * 60, PostPaddingSeconds = item.EndOffset * 60, RecordAnyChannel = !((item.Filter & RecFilter.ThisChannel) == RecFilter.ThisChannel), RecordAnyTime = !((item.Filter & RecFilter.ThisDayTime) == RecFilter.ThisDayTime), RecordNewOnly = ((item.Filter & RecFilter.NewEpisode) == RecFilter.NewEpisode), //IsPostPaddingRequired = item.EndOffset != 0, //IsPrePaddingRequired = item.StartOffset != 0, ProgramId = item.ProgramId }; ret.Add(val); } } return ret; }
public SingleTimer(ProgramInfo parent, SeriesTimerInfo series) { ChannelId = parent.ChannelId; Id = parent.Id; StartDate = parent.StartDate; EndDate = parent.EndDate; ProgramId = parent.Id; PrePaddingSeconds = series.PrePaddingSeconds; PostPaddingSeconds = series.PostPaddingSeconds; IsPostPaddingRequired = series.IsPostPaddingRequired; IsPrePaddingRequired = series.IsPrePaddingRequired; Priority = series.Priority; Name = parent.Name; Overview = parent.Overview; SeriesTimerId = series.Id; }
public static TimerInfo CreateTimer(ProgramInfo parent, SeriesTimerInfo series) { var timer = new TimerInfo(); timer.ChannelId = parent.ChannelId; timer.Id = (series.Id + parent.Id).GetMD5().ToString("N"); timer.StartDate = parent.StartDate; timer.EndDate = parent.EndDate; timer.ProgramId = parent.Id; timer.PrePaddingSeconds = series.PrePaddingSeconds; timer.PostPaddingSeconds = series.PostPaddingSeconds; timer.IsPostPaddingRequired = series.IsPostPaddingRequired; timer.IsPrePaddingRequired = series.IsPrePaddingRequired; timer.Priority = series.Priority; timer.Name = parent.Name; timer.Overview = parent.Overview; timer.SeriesTimerId = series.Id; return timer; }
public SeriesTimerInfoDto GetSeriesTimerInfoDto(SeriesTimerInfo info, ILiveTvService service, string channelName) { var dto = new SeriesTimerInfoDto { Id = GetInternalSeriesTimerId(service.Name, info.Id).ToString("N"), Overview = info.Overview, EndDate = info.EndDate, Name = info.Name, StartDate = info.StartDate, ExternalId = info.Id, PrePaddingSeconds = info.PrePaddingSeconds, PostPaddingSeconds = info.PostPaddingSeconds, IsPostPaddingRequired = info.IsPostPaddingRequired, IsPrePaddingRequired = info.IsPrePaddingRequired, Days = info.Days, Priority = info.Priority, RecordAnyChannel = info.RecordAnyChannel, RecordAnyTime = info.RecordAnyTime, RecordNewOnly = info.RecordNewOnly, ExternalChannelId = info.ChannelId, ExternalProgramId = info.ProgramId, ServiceName = service.Name, ChannelName = channelName, ServerId = _appHost.SystemId }; if (!string.IsNullOrEmpty(info.ChannelId)) { dto.ChannelId = GetInternalChannelId(service.Name, info.ChannelId).ToString("N"); } if (!string.IsNullOrEmpty(info.ProgramId)) { dto.ProgramId = GetInternalProgramId(service.Name, info.ProgramId).ToString("N"); } dto.DayPattern = info.Days == null ? null : GetDayPattern(info.Days); return dto; }
public void ChangeSeriesSchedule(CancellationToken cancellationToken, SeriesTimerInfo schedule) { var timerData = GetSchedule(cancellationToken, schedule.Id); if (timerData == null) { throw ExceptionHelper.CreateArgumentException("schedule.Id", "The schedule id {0} could not be found", schedule.Id); } var builder = new StringBuilder("AddScheduleDetailed?"); builder.AppendFormat("channelid={0}&", timerData.ChannelId); builder.AppendFormat("title={0}&", timerData.Title); builder.AppendFormat("starttime={0}&", timerData.StartTime.ToLocalTime().ToUrlDate()); builder.AppendFormat("endtime={0}&", timerData.EndTime.ToLocalTime().ToUrlDate()); builder.AppendFormat("scheduletype={0}&", (Int32)schedule.ToScheduleType()); if (schedule.IsPrePaddingRequired & schedule.PrePaddingSeconds > 0) { builder.AppendFormat("preRecordInterval={0}&", TimeSpan.FromSeconds(schedule.PrePaddingSeconds).RoundUpMinutes()); } if (schedule.IsPostPaddingRequired & schedule.PostPaddingSeconds > 0) { builder.AppendFormat("postRecordInterval={0}&", TimeSpan.FromSeconds(schedule.PostPaddingSeconds).RoundUpMinutes()); } builder.Remove(builder.Length - 1, 1); Plugin.Logger.Info("Creating series schedule with StartTime: {0}, EndTime: {1}, ProgramData from MP: {2}", schedule.StartDate, schedule.EndDate, builder.ToString()); Plugin.TvProxy.DeleteSchedule(cancellationToken, schedule.Id); var response = GetFromService<WebBoolResult>(cancellationToken, builder.ToString()); if (!response.Result) { throw new LiveTvConflictException(); } }
public Task<SeriesTimerInfo> GetNewTimerDefaultsAsync(CancellationToken cancellationToken, ProgramInfo program = null) { var config = GetConfiguration(); var defaults = new SeriesTimerInfo() { PostPaddingSeconds = Math.Max(config.PostPaddingSeconds, 0), PrePaddingSeconds = Math.Max(config.PrePaddingSeconds, 0), RecordAnyChannel = true, RecordAnyTime = true, RecordNewOnly = false, Days = new List<DayOfWeek> { DayOfWeek.Sunday, DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday, DayOfWeek.Thursday, DayOfWeek.Friday, DayOfWeek.Saturday } }; if (program != null) { defaults.SeriesId = program.SeriesId; defaults.ProgramId = program.Id; } return Task.FromResult(defaults); }
public async Task UpdateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken) { var instance = _seriesTimerProvider.GetAll().FirstOrDefault(i => string.Equals(i.Id, info.Id, StringComparison.OrdinalIgnoreCase)); if (instance != null) { instance.ChannelId = info.ChannelId; instance.Days = info.Days; instance.EndDate = info.EndDate; instance.IsPostPaddingRequired = info.IsPostPaddingRequired; instance.IsPrePaddingRequired = info.IsPrePaddingRequired; instance.PostPaddingSeconds = info.PostPaddingSeconds; instance.PrePaddingSeconds = info.PrePaddingSeconds; instance.Priority = info.Priority; instance.RecordAnyChannel = info.RecordAnyChannel; instance.RecordAnyTime = info.RecordAnyTime; instance.RecordNewOnly = info.RecordNewOnly; instance.StartDate = info.StartDate; _seriesTimerProvider.Update(instance); List<ProgramInfo> epgData; if (instance.RecordAnyChannel) { var channels = await GetChannelsAsync(true, CancellationToken.None).ConfigureAwait(false); var channelIds = channels.Select(i => i.Id).ToList(); epgData = GetEpgDataForChannels(channelIds); } else { epgData = GetEpgDataForChannel(instance.ChannelId); } await UpdateTimersForSeriesTimer(epgData, instance, true).ConfigureAwait(false); } }
public Task<IEnumerable<SeriesTimerInfo>> buildAutorecInfos(CancellationToken cancellationToken) { return Task.Factory.StartNew<IEnumerable<SeriesTimerInfo>>(() => { lock (_data) { List<SeriesTimerInfo> result = new List<SeriesTimerInfo>(); foreach (KeyValuePair<string, Message> entry in _data) { if (cancellationToken.IsCancellationRequested) { _logger.Info("[TVHclient] DvrDataHelper.buildDvrInfos, call canceled - returning part list."); return result; } Message m = entry.Value; SeriesTimerInfo sti = new SeriesTimerInfo(); try { if (m.containsField("id")) { sti.Id = m.getString("id"); } } catch (InvalidCastException) { } try { if (m.containsField("daysOfWeek")) { int daysOfWeek = m.getInt("daysOfWeek"); sti.Days = getDayOfWeekListFromInt(daysOfWeek); } } catch (InvalidCastException) { } sti.StartDate = DateTime.Now.ToUniversalTime(); try { if (m.containsField("retention")) { int retentionInDays = m.getInt("retention"); sti.EndDate = DateTime.Now.AddDays(retentionInDays).ToUniversalTime(); } } catch (InvalidCastException) { } try { if (m.containsField("channel")) { sti.ChannelId = "" + m.getInt("channel"); } } catch (InvalidCastException) { } try { if (m.containsField("startExtra")) { sti.PrePaddingSeconds = (int)m.getLong("startExtra") * 60; sti.IsPrePaddingRequired = true; } } catch (InvalidCastException) { } try { if (m.containsField("stopExtra")) { sti.PostPaddingSeconds = (int)m.getLong("stopExtra") * 60; sti.IsPostPaddingRequired = true; } } catch (InvalidCastException) { } try { if (m.containsField("title")) { sti.Name = m.getString("title"); } } catch (InvalidCastException) { } try { if (m.containsField("description")) { sti.Overview = m.getString("description"); } } catch (InvalidCastException) { } try { if (m.containsField("priority")) { sti.Priority = m.getInt("priority"); } } catch (InvalidCastException) { } /* public string ProgramId { get; set; } public bool RecordAnyChannel { get; set; } public bool RecordAnyTime { get; set; } public bool RecordNewOnly { get; set; } */ result.Add(sti); } return result; } }); }
public Task UpdateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken) { UpdateTimersForSeriesTimer(info); _seriesTimerProvider.Update(info); return Task.FromResult(true); }
public Task CreateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken) { info.Id = info.ProgramId.Substring(0, 10); UpdateTimersForSeriesTimer(info); _seriesTimerProvider.Add(info); return Task.FromResult(true); }
private SeriesTimerInfo GetSeriesTimerInfo(EpgEventJSONObject i) { var info = new SeriesTimerInfo(); var recurr = i.recurr; if (recurr != null) { info.ChannelId = GetChannelId(recurr); info.Id = recurr.OID.ToString(_usCulture); info.StartDate = DateTime.Parse(recurr.StartTime).ToUniversalTime(); info.EndDate = DateTime.Parse(recurr.EndTime).ToUniversalTime(); info.PrePaddingSeconds = int.Parse(recurr.PrePadding, _usCulture) * 60; info.PostPaddingSeconds = int.Parse(recurr.PostPadding, _usCulture) * 60; info.Name = recurr.RecurringName ?? recurr.EPGTitle; info.RecordNewOnly = recurr.OnlyNew; info.RecordAnyChannel = recurr.allChannels; info.Days = (recurr.Day ?? string.Empty).Split(',') .Select(d => (DayOfWeek)Enum.Parse(typeof(DayOfWeek), d.Trim(), true)) .ToList(); info.Priority = recurr.Priority; } var epg = i.epgEvent; if (epg != null) { info.ProgramId = epg.OID.ToString(_usCulture); info.Overview = epg.Desc; } return info; }
private void UpdateScheduling(SeriesTimerInfo seriesTimerInfo, Schedule schedule) { var schedulingType = (WebScheduleType)schedule.ScheduleType; // Initialise seriesTimerInfo.Days = new List<DayOfWeek>(); seriesTimerInfo.RecordAnyChannel = false; seriesTimerInfo.RecordAnyTime = false; seriesTimerInfo.RecordNewOnly = false; switch (schedulingType) { case WebScheduleType.EveryTimeOnThisChannel: seriesTimerInfo.RecordAnyTime = true; break; case WebScheduleType.EveryTimeOnEveryChannel: seriesTimerInfo.RecordAnyTime = true; seriesTimerInfo.RecordAnyChannel = true; break; case WebScheduleType.WeeklyEveryTimeOnThisChannel: seriesTimerInfo.Days.Add(schedule.StartTime.DayOfWeek); seriesTimerInfo.RecordAnyTime = true; break; case WebScheduleType.Daily: seriesTimerInfo.Days.AddRange(new[] { DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday, DayOfWeek.Thursday, DayOfWeek.Friday, DayOfWeek.Saturday, DayOfWeek.Sunday, }); break; case WebScheduleType.WorkingDays: seriesTimerInfo.Days.AddRange(new[] { DayOfWeek.Monday, DayOfWeek.Tuesday, DayOfWeek.Wednesday, DayOfWeek.Thursday, DayOfWeek.Friday, }); break; case WebScheduleType.Weekends: seriesTimerInfo.Days.AddRange(new[] { DayOfWeek.Saturday, DayOfWeek.Sunday, }); break; case WebScheduleType.Weekly: seriesTimerInfo.Days.Add(schedule.StartTime.DayOfWeek); break; default: throw new InvalidOperationException(String.Format("Should not be processing scheduling for ScheduleType={0}", schedulingType)); } }
public IEnumerable<SeriesTimerInfo> GetSeriesSchedules(CancellationToken cancellationToken) { var response = GetFromService<List<Schedule>>(cancellationToken, "GetSchedules"); var recordings = response.Where(r => r.ScheduleType > 0).Select(r => { var seriesTimerInfo = new SeriesTimerInfo() { ChannelId = r.ChannelId.ToString(CultureInfo.InvariantCulture), EndDate = r.EndTime, Id = r.Id.ToString(CultureInfo.InvariantCulture), SeriesId = r.Id.ToString(CultureInfo.InvariantCulture), ProgramId = r.Id.ToString(CultureInfo.InvariantCulture), Name = r.Title, IsPostPaddingRequired = (r.PostRecordInterval > 0), IsPrePaddingRequired = (r.PreRecordInterval > 0), PostPaddingSeconds = r.PostRecordInterval * 60, PrePaddingSeconds = r.PreRecordInterval * 60, StartDate = r.StartTime, }; UpdateScheduling(seriesTimerInfo, r); return seriesTimerInfo; }); return recordings; }
private IEnumerable<TimerInfo> GetTimersForSeries(SeriesTimerInfo seriesTimer, IEnumerable<ProgramInfo> allPrograms, IReadOnlyList<RecordingInfo> currentRecordings) { // Exclude programs that have already ended allPrograms = allPrograms.Where(i => i.EndDate > DateTime.UtcNow); allPrograms = GetProgramsForSeries(seriesTimer, allPrograms); var recordingShowIds = currentRecordings.Select(i => i.ProgramId).Where(i => !string.IsNullOrWhiteSpace(i)).ToList(); allPrograms = allPrograms.Where(i => !recordingShowIds.Contains(i.Id, StringComparer.OrdinalIgnoreCase)); return allPrograms.Select(i => RecordingHelper.CreateTimer(i, seriesTimer)); }
private async Task UpdateTimersForSeriesTimer(List<ProgramInfo> epgData, SeriesTimerInfo seriesTimer) { var registration = await GetRegistrationInfo("seriesrecordings").ConfigureAwait(false); if (registration.IsValid) { var newTimers = GetTimersForSeries(seriesTimer, epgData, _recordingProvider.GetAll()).ToList(); foreach (var timer in newTimers) { _timerProvider.AddOrUpdate(timer); } } }
public Task<SeriesTimerInfo> GetNewTimerDefaultsAsync(CancellationToken cancellationToken, ProgramInfo program = null) { var config = GetConfiguration(); var defaults = new SeriesTimerInfo() { PostPaddingSeconds = Math.Max(config.PostPaddingSeconds, 0), PrePaddingSeconds = Math.Max(config.PrePaddingSeconds, 0), RecordAnyChannel = false, RecordAnyTime = false, RecordNewOnly = false }; if (program != null) { defaults.SeriesId = program.SeriesId; defaults.ProgramId = program.Id; } return Task.FromResult(defaults); }
public async Task UpdateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken) { _seriesTimerProvider.Update(info); List<ProgramInfo> epgData; if (info.RecordAnyChannel) { var channels = await GetChannelsAsync(true, CancellationToken.None).ConfigureAwait(false); var channelIds = channels.Select(i => i.Id).ToList(); epgData = GetEpgDataForChannels(channelIds); } else { epgData = GetEpgDataForChannel(info.ChannelId); } await UpdateTimersForSeriesTimer(epgData, info).ConfigureAwait(false); }
/// <summary> /// Create a recurrent recording /// </summary> /// <param name="info">The recurrend program info</param> /// <param name="cancellationToken">The CancelationToken</param> /// <returns></returns> public async Task CreateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken) { _logger.Info(string.Format("[NextPvr] Start CreateSeriesTimer Async for ChannelId: {0} & Name: {1}", info.ChannelId, info.Name)); await EnsureConnectionAsync(cancellationToken).ConfigureAwait(false); var baseUrl = Plugin.Instance.Configuration.WebServiceUrl; var options = new HttpRequestOptions { CancellationToken = cancellationToken, Url = string.Format("{0}/public/ScheduleService/Record?sid={1}", baseUrl, Sid) }; var timerSettings = await GetDefaultScheduleSettings(cancellationToken).ConfigureAwait(false); timerSettings.allChannels = info.RecordAnyChannel; timerSettings.onlyNew = info.RecordNewOnly; timerSettings.recurringName = info.Name; timerSettings.recordAnyTimeslot = info.RecordAnyTime; if (!info.RecordAnyTime) { timerSettings.startDate = info.StartDate.ToString(_usCulture); timerSettings.endDate = info.EndDate.ToString(_usCulture); timerSettings.recordThisTimeslot = true; } if (info.Days.Count == 1) { timerSettings.recordThisDay = true; } if (info.Days.Count > 1 && info.Days.Count < 7) { timerSettings.recordSpecificdays = true; } timerSettings.recordAnyDay = info.Days.Count == 7; timerSettings.daySunday = info.Days.Contains(DayOfWeek.Sunday); timerSettings.dayMonday = info.Days.Contains(DayOfWeek.Monday); timerSettings.dayTuesday = info.Days.Contains(DayOfWeek.Tuesday); timerSettings.dayWednesday = info.Days.Contains(DayOfWeek.Wednesday); timerSettings.dayThursday = info.Days.Contains(DayOfWeek.Thursday); timerSettings.dayFriday = info.Days.Contains(DayOfWeek.Friday); timerSettings.daySaturday = info.Days.Contains(DayOfWeek.Saturday); if (!info.RecordAnyChannel) { timerSettings.ChannelOID = int.Parse(info.ChannelId, _usCulture); } if (!string.IsNullOrEmpty(info.ProgramId)) { timerSettings.epgeventOID = int.Parse(info.ProgramId, _usCulture); } timerSettings.post_padding_min = info.PostPaddingSeconds / 60; timerSettings.pre_padding_min = info.PrePaddingSeconds / 60; var postContent = _jsonSerializer.SerializeToString(timerSettings); UtilsHelper.DebugInformation(_logger, string.Format("[NextPvr] TimerSettings CreateSeriesTimer: {0} for ChannelId: {1} & Name: {2}", postContent, info.ChannelId, info.Name)); options.RequestContent = postContent; options.RequestContentType = "application/json"; try { await _httpClient.Post(options).ConfigureAwait((false)); } catch (HttpException ex) { _logger.Error(string.Format("[NextPvr] CreateSeries async with exception: {0} ", ex.Message)); throw new LiveTvConflictException(); } }
private async Task UpdateTimersForSeriesTimer(List<ProgramInfo> epgData, SeriesTimerInfo seriesTimer, bool deleteInvalidTimers) { var newTimers = GetTimersForSeries(seriesTimer, epgData, true).ToList(); var registration = await GetRegistrationInfo("seriesrecordings").ConfigureAwait(false); if (registration.IsValid) { foreach (var timer in newTimers) { _timerProvider.AddOrUpdate(timer); } } if (deleteInvalidTimers) { var allTimers = GetTimersForSeries(seriesTimer, epgData, false) .Select(i => i.Id) .ToList(); var deletes = _timerProvider.GetAll() .Where(i => string.Equals(i.SeriesTimerId, seriesTimer.Id, StringComparison.OrdinalIgnoreCase)) .Where(i => !allTimers.Contains(i.Id, StringComparer.OrdinalIgnoreCase) && i.StartDate > DateTime.UtcNow) .ToList(); foreach (var timer in deletes) { await CancelTimerAsync(timer.Id, CancellationToken.None).ConfigureAwait(false); } } }
/// <summary> /// Update the series Timer /// </summary> /// <param name="info">The series program info</param> /// <param name="cancellationToken">The CancellationToken</param> /// <returns></returns> public async Task UpdateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken) { _logger.Info(string.Format("[NextPvr] Start UpdateSeriesTimer Async for ChannelId: {0} & Name: {1}", info.ChannelId, info.Name)); await EnsureConnectionAsync(cancellationToken).ConfigureAwait(false); var baseUrl = Plugin.Instance.Configuration.WebServiceUrl; var options = new HttpRequestOptions { CancellationToken = cancellationToken, Url = string.Format("{0}/public/ScheduleService/UpdateRecurr?sid={1}", baseUrl, Sid) }; var timerSettings = await GetDefaultScheduleSettings(cancellationToken).ConfigureAwait(false); timerSettings.recurrOID = int.Parse(info.Id); timerSettings.post_padding_min = info.PostPaddingSeconds / 60; timerSettings.pre_padding_min = info.PrePaddingSeconds / 60; timerSettings.recurringName = info.Name; timerSettings.keep_all_days = true; timerSettings.days_to_keep = 0; timerSettings.extend_end_time_min = 0; var postContent = _jsonSerializer.SerializeToString(timerSettings); UtilsHelper.DebugInformation(_logger, string.Format("[NextPvr] TimerSettings UpdateSeriesTimer: {0} for ChannelId: {1} & Name: {2}", postContent, info.ChannelId, info.Name)); options.RequestContent = postContent; options.RequestContentType = "application/json"; try { await _httpClient.Post(options).ConfigureAwait((false)); } catch (HttpException ex) { _logger.Error(string.Format("[NextPvr] UpdateSeries async with exception: {0}", ex.Message)); throw new LiveTvConflictException(); } }
private IEnumerable<TimerInfo> GetTimersForSeries(SeriesTimerInfo seriesTimer, IEnumerable<ProgramInfo> allPrograms, bool filterByCurrentRecordings) { if (seriesTimer == null) { throw new ArgumentNullException("seriesTimer"); } if (allPrograms == null) { throw new ArgumentNullException("allPrograms"); } // Exclude programs that have already ended allPrograms = allPrograms.Where(i => i.EndDate > DateTime.UtcNow && i.StartDate > DateTime.UtcNow); allPrograms = GetProgramsForSeries(seriesTimer, allPrograms); if (filterByCurrentRecordings) { allPrograms = allPrograms.Where(i => !IsProgramAlreadyInLibrary(i)); } return allPrograms.Select(i => RecordingHelper.CreateTimer(i, seriesTimer)); }
public async Task<SeriesTimerInfo> GetSeriesTimerInfo(SeriesTimerInfoDto dto, bool isNew, LiveTvManager liveTv, CancellationToken cancellationToken) { var info = new SeriesTimerInfo { Overview = dto.Overview, EndDate = dto.EndDate, Name = dto.Name, StartDate = dto.StartDate, PrePaddingSeconds = dto.PrePaddingSeconds, PostPaddingSeconds = dto.PostPaddingSeconds, IsPostPaddingRequired = dto.IsPostPaddingRequired, IsPrePaddingRequired = dto.IsPrePaddingRequired, Days = dto.Days, Priority = dto.Priority, RecordAnyChannel = dto.RecordAnyChannel, RecordAnyTime = dto.RecordAnyTime, RecordNewOnly = dto.RecordNewOnly, ProgramId = dto.ExternalProgramId, ChannelId = dto.ExternalChannelId, Id = dto.ExternalId }; // Convert internal server id's to external tv provider id's if (!isNew && !string.IsNullOrEmpty(dto.Id) && string.IsNullOrEmpty(info.Id)) { var timer = await liveTv.GetSeriesTimer(dto.Id, cancellationToken).ConfigureAwait(false); info.Id = timer.ExternalId; } if (!string.IsNullOrEmpty(dto.ChannelId) && string.IsNullOrEmpty(info.ChannelId)) { var channel = liveTv.GetInternalChannel(dto.ChannelId); if (channel != null) { info.ChannelId = channel.ExternalId; } } if (!string.IsNullOrEmpty(dto.ProgramId) && string.IsNullOrEmpty(info.ProgramId)) { var program = liveTv.GetInternalProgram(dto.ProgramId); if (program != null) { info.ProgramId = program.ExternalId; } } return info; }
public void CopyTimer(SeriesTimerInfo parent) { foreach (PropertyInfo prop in parent.GetType().GetProperties()) { GetType().GetProperty(prop.Name).SetValue(this, prop.GetValue(parent, null), null); } }
private void UpdateTimersForSeriesTimer(SeriesTimerInfo seriesTimer) { List<ProgramInfo> epgData; if (seriesTimer.RecordAnyChannel) { epgData = GetEpgDataForAllChannels(); } else { epgData = GetEpgDataForChannel(seriesTimer.ChannelId); } var newTimers = RecordingHelper.GetTimersForSeries(seriesTimer, epgData, _recordingProvider.GetAll(), _logger); var existingTimers = _timerProvider.GetAll() .Where(i => string.Equals(i.SeriesTimerId, seriesTimer.Id, StringComparison.OrdinalIgnoreCase)) .ToList(); foreach (var timer in newTimers) { _timerProvider.AddOrUpdate(timer); } var newTimerIds = newTimers.Select(i => i.Id).ToList(); foreach (var timer in existingTimers) { if (!newTimerIds.Contains(timer.Id, StringComparer.OrdinalIgnoreCase)) { CancelTimerInternal(timer.Id); } } }
public Task CreateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken) { return CreateSeriesTimer(info, cancellationToken); }
public Task<SeriesTimerInfo> GetNewTimerDefaultsAsync(CancellationToken cancellationToken, ProgramInfo program = null) { var defaults = new SeriesTimerInfo() { PostPaddingSeconds = 60, PrePaddingSeconds = 60, RecordAnyChannel = false, RecordAnyTime = false, RecordNewOnly = false }; return Task.FromResult(defaults); }
public async Task<string> CreateSeriesTimer(SeriesTimerInfo info, CancellationToken cancellationToken) { info.Id = Guid.NewGuid().ToString("N"); List<ProgramInfo> epgData; if (info.RecordAnyChannel) { var channels = await GetChannelsAsync(true, CancellationToken.None).ConfigureAwait(false); var channelIds = channels.Select(i => i.Id).ToList(); epgData = GetEpgDataForChannels(channelIds); } else { epgData = GetEpgDataForChannel(info.ChannelId); } // populate info.seriesID var program = epgData.FirstOrDefault(i => string.Equals(i.Id, info.ProgramId, StringComparison.OrdinalIgnoreCase)); if (program != null) { info.SeriesId = program.SeriesId; } else { throw new InvalidOperationException("SeriesId for program not found"); } _seriesTimerProvider.Add(info); await UpdateTimersForSeriesTimer(epgData, info, false).ConfigureAwait(false); return info.Id; }
private IEnumerable<ProgramInfo> GetProgramsForSeries(SeriesTimerInfo seriesTimer, IEnumerable<ProgramInfo> allPrograms) { if (!seriesTimer.RecordAnyTime) { allPrograms = allPrograms.Where(epg => Math.Abs(seriesTimer.StartDate.TimeOfDay.Ticks - epg.StartDate.TimeOfDay.Ticks) < TimeSpan.FromMinutes(5).Ticks); allPrograms = allPrograms.Where(i => seriesTimer.Days.Contains(i.StartDate.ToLocalTime().DayOfWeek)); } if (seriesTimer.RecordNewOnly) { allPrograms = allPrograms.Where(epg => !epg.IsRepeat); } if (!seriesTimer.RecordAnyChannel) { allPrograms = allPrograms.Where(epg => string.Equals(epg.ChannelId, seriesTimer.ChannelId, StringComparison.OrdinalIgnoreCase)); } if (string.IsNullOrWhiteSpace(seriesTimer.SeriesId)) { _logger.Error("seriesTimer.SeriesId is null. Cannot find programs for series"); return new List<ProgramInfo>(); } return allPrograms.Where(i => string.Equals(i.SeriesId, seriesTimer.SeriesId, StringComparison.OrdinalIgnoreCase)); }
public async Task UpdateSeriesTimerAsync(SeriesTimerInfo info, CancellationToken cancellationToken) { Logger.Debug("LiveTvService.UpdateSeriesTimerAsync"); await Task.Run(() => true, cancellationToken); }