public static ScheduleDaysOfWeek GetScheduleDaysOfWeek(List <DayOfWeek> daysOfWeekToRecord)
{
ScheduleDaysOfWeek daysOfWeek = ScheduleDaysOfWeek.None;
if (daysOfWeekToRecord.Contains(DayOfWeek.Monday))
{
daysOfWeek |= ScheduleDaysOfWeek.Mondays;
}
if (daysOfWeekToRecord.Contains(DayOfWeek.Monday))
{
daysOfWeek |= ScheduleDaysOfWeek.Tuesdays;
}
if (daysOfWeekToRecord.Contains(DayOfWeek.Monday))
{
daysOfWeek |= ScheduleDaysOfWeek.Wednesdays;
}
if (daysOfWeekToRecord.Contains(DayOfWeek.Monday))
{
daysOfWeek |= ScheduleDaysOfWeek.Thursdays;
}
if (daysOfWeekToRecord.Contains(DayOfWeek.Monday))
{
daysOfWeek |= ScheduleDaysOfWeek.Fridays;
}
if (daysOfWeekToRecord.Contains(DayOfWeek.Monday))
{
daysOfWeek |= ScheduleDaysOfWeek.Saturdays;
}
if (daysOfWeekToRecord.Contains(DayOfWeek.Monday))
{
daysOfWeek |= ScheduleDaysOfWeek.Sundays;
}
return(daysOfWeek);
}
private void UpdateRules()
{
if (_model.IsManual)
{
ChannelListItem channelItem = _manualChannelComboBox.SelectedItem as ChannelListItem;
if (channelItem != null &&
channelItem.ChannelId != Guid.Empty &&
(_manualDurationDateTimePicker.Value.Hour != 0 || _manualDurationDateTimePicker.Value.Minute != 0))
{
DateTime startTime = _manualDatePicker.Value.Date.Add(
new TimeSpan(_manualTimePicker.Value.Hour, _manualTimePicker.Value.Minute, 0));
TimeSpan duration =
new TimeSpan(_manualDurationDateTimePicker.Value.Hour, _manualDurationDateTimePicker.Value.Minute, 0);
ScheduleDaysOfWeek daysOfWeek = _manualScheduleDaysOfWeekControl.ScheduleDaysOfWeek;
_controller.UpdateManualSchedule(channelItem.ChannelId, channelItem.ChannelDisplayName, startTime, duration, daysOfWeek);
_nameTextBox.Text = _model.Schedule.Name;
}
}
else
{
List <ScheduleRule> rules = new List <ScheduleRule>();
_controller.AppendTitleRule(rules, _titleRuleTypeComboBox.SelectedIndex, _titleTextBox.Text);
_controller.AppendSubTitleRule(rules, _subTitleRuleTypeComboBox.SelectedIndex, _subTitleTextBox.Text);
_controller.AppendEpisodeNumberRule(rules, _episodeNumberRuleTypeComboBox.SelectedIndex, _episodeNumberTextBox.Text);
if (_descriptionOrAnyComboBox.SelectedIndex == 1)
{
_controller.AppendDescriptionRule(rules, _descriptionOrAnyTextBox.Text);
}
else
{
_controller.AppendProgramInfoRule(rules, _descriptionOrAnyTextBox.Text);
}
_controller.AppendOnDateAndDaysOfWeekRule(rules, _scheduleDaysOfWeekControl.ScheduleDaysOfWeek,
_onDateDateTimePicker.Checked ? _onDateDateTimePicker.Value : (DateTime?)null);
_controller.AppendAroundTimeRule(rules, _aroundCheckBox.Checked ? _aroundDateTimePicker.Value : (DateTime?)null);
_controller.AppendStartingBetweenRule(rules, _betweenCheckBox.Checked, _betweenFromDateTimePicker.Value, _betweenToDateTimePicker.Value);
_controller.AppendCategoriesRule(rules, _notInCategoriesRadioButton.Checked, _categoriesListBox.Items);
_controller.AppendDirectedByRule(rules, _directorsListBox.Items);
_controller.AppendWithActorRule(rules, _actorsListBox.Items);
_controller.AppendNewEpisodesOnlyRule(rules, _newEpisodesOnlyCheckBox.Checked);
_controller.AppendNewTitlesOnlyRule(rules, _newTitlesOnlyCheckBox.Checked);
_controller.AppendSkipRepeatsRule(rules, _skipRepeatsCheckBox.Checked);
List <Guid> channelIds = new List <Guid>();
foreach (ChannelListItem item in _tvChannelsListBox.Items)
{
channelIds.Add(item.ChannelId);
}
_controller.AppendChannelsRule(rules, _notInChannelsRadioButton.Checked, channelIds);
_model.Schedule.Rules = rules;
}
}
public static List <DayOfWeek> GetDaysOfWeek(ScheduleDaysOfWeek scheduleDaysOfWeek)
{
var daysOfWeek = new List <DayOfWeek>();
if ((scheduleDaysOfWeek & ScheduleDaysOfWeek.Mondays) != 0)
{
daysOfWeek.Add(DayOfWeek.Monday);
}
if ((scheduleDaysOfWeek & ScheduleDaysOfWeek.Tuesdays) != 0)
{
daysOfWeek.Add(DayOfWeek.Tuesday);
}
if ((scheduleDaysOfWeek & ScheduleDaysOfWeek.Wednesdays) != 0)
{
daysOfWeek.Add(DayOfWeek.Wednesday);
}
if ((scheduleDaysOfWeek & ScheduleDaysOfWeek.Thursdays) != 0)
{
daysOfWeek.Add(DayOfWeek.Thursday);
}
if ((scheduleDaysOfWeek & ScheduleDaysOfWeek.Fridays) != 0)
{
daysOfWeek.Add(DayOfWeek.Friday);
}
if ((scheduleDaysOfWeek & ScheduleDaysOfWeek.Saturdays) != 0)
{
daysOfWeek.Add(DayOfWeek.Saturday);
}
if ((scheduleDaysOfWeek & ScheduleDaysOfWeek.Sundays) != 0)
{
daysOfWeek.Add(DayOfWeek.Sunday);
}
return(daysOfWeek);
}
public void AppendOnDateAndDaysOfWeekRule(List <ScheduleRule> rules, ScheduleDaysOfWeek daysOfWeek, DateTime?onDateTime)
{
if (daysOfWeek == ScheduleDaysOfWeek.None)
{
if (onDateTime.HasValue)
{
rules.Add(ScheduleRuleType.OnDate, onDateTime.Value.Date);
}
}
else
{
if (onDateTime.HasValue)
{
rules.Add(ScheduleRuleType.DaysOfWeek, daysOfWeek, onDateTime.Value.Date);
}
else
{
rules.Add(ScheduleRuleType.DaysOfWeek, daysOfWeek);
}
}
}
public static void AppendOnDateAndDaysOfWeekRule(ScheduleRules rules, ScheduleDaysOfWeek daysOfWeek, DateTime? onDateTime)
{
if (daysOfWeek == ScheduleDaysOfWeek.None)
{
if (onDateTime.HasValue)
{
rules.Add(ScheduleRuleType.OnDate, onDateTime.Value.Date);
}
}
else
{
if (onDateTime.HasValue)
{
rules.Add(ScheduleRuleType.DaysOfWeek, daysOfWeek, onDateTime.Value.Date);
}
else
{
rules.Add(ScheduleRuleType.DaysOfWeek, daysOfWeek);
}
}
}
private string BuildManualScheduleName(string channelDisplayName, DateTime startTime, TimeSpan duration, ScheduleDaysOfWeek daysOfWeek)
{
StringBuilder name = new StringBuilder();
if (daysOfWeek == ScheduleDaysOfWeek.None)
{
name.AppendFormat("{0} {1:g} ({2:00}:{3:00})", channelDisplayName, startTime, duration.Hours, duration.Minutes);
}
else
{
name.AppendFormat("{0} ", channelDisplayName);
if ((daysOfWeek & ScheduleDaysOfWeek.Mondays) != 0)
{
name.Append("Mo,");
}
if ((daysOfWeek & ScheduleDaysOfWeek.Tuesdays) != 0)
{
name.Append("Tu,");
}
if ((daysOfWeek & ScheduleDaysOfWeek.Wednesdays) != 0)
{
name.Append("We,");
}
if ((daysOfWeek & ScheduleDaysOfWeek.Thursdays) != 0)
{
name.Append("Th,");
}
if ((daysOfWeek & ScheduleDaysOfWeek.Fridays) != 0)
{
name.Append("Fr,");
}
if ((daysOfWeek & ScheduleDaysOfWeek.Saturdays) != 0)
{
name.Append("Sa,");
}
if ((daysOfWeek & ScheduleDaysOfWeek.Sundays) != 0)
{
name.Append("Su,");
}
name.Remove(name.Length - 1, 1);
name.AppendFormat(" at {0:00}:{1:00} ({2:00}:{3:00})",
startTime.TimeOfDay.Hours, startTime.TimeOfDay.Minutes, duration.Hours, duration.Minutes);
}
return(name.ToString());
}
public void UpdateManualSchedule(Guid channelId, string channelDisplayName, DateTime startTime, TimeSpan duration, ScheduleDaysOfWeek daysOfWeek)
{
List <ScheduleRule> rules = new List <ScheduleRule>();
rules.Add(ScheduleRuleType.Channels, channelId);
rules.Add(ScheduleRuleType.ManualSchedule, startTime, new ScheduleTime(duration));
if (daysOfWeek != ScheduleDaysOfWeek.None)
{
rules.Add(ScheduleRuleType.DaysOfWeek, daysOfWeek);
}
_model.Schedule.Name = BuildManualScheduleName(channelDisplayName, startTime, duration, daysOfWeek);
_model.Schedule.Rules = rules;
}
private void Onrecord(ScheduleType scheduleType)
{
Schedule schedule = null;
if (_upcomingProgram != null)
{
schedule = SchedulerAgent.GetScheduleById(_upcomingProgram.ScheduleId);
}
if (_upcomingProgram != null && schedule != null
&& schedule.ScheduleType == scheduleType)//delete schedule
{
if (_upcomingProgram.IsCancelled)
{
SchedulerAgent.UncancelUpcomingProgram(_upcomingProgram.ScheduleId, _upcomingProgram.GuideProgramId, _upcomingProgram.Channel.ChannelId, _upcomingProgram.StartTime);
try
{
//refresh _upcomingProgram
_upcomingProgram = SchedulerAgent.GetUpcomingPrograms(schedule, true)[0];
}
catch { }
}
else
{
if (_upcomingProgram.IsPartOfSeries)
{
GUIDialogYesNo dlgYesNo = (GUIDialogYesNo)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_YES_NO);
if (dlgYesNo != null)
{
dlgYesNo.SetHeading(Utility.GetLocalizedText(TextId.DeleteEntireSchedule));
dlgYesNo.SetLine(1, "\"" + schedule.Name + "\"");
dlgYesNo.SetLine(2, Utility.GetLocalizedText(TextId.AreYouSure));
dlgYesNo.SetLine(3, String.Empty);
dlgYesNo.SetDefaultToYes(false);
dlgYesNo.DoModal(GUIWindowManager.ActiveWindow);
if (dlgYesNo.IsConfirmed)
{
SchedulerAgent.DeleteSchedule(schedule.ScheduleId);
_upcomingProgram = null;
}
}
}
else
{
SchedulerAgent.DeleteSchedule(_upcomingProgram.ScheduleId);
_upcomingProgram = null;
}
}
}
else//create new schedule
{
TimeSpan duration = new TimeSpan(Int32.Parse(_spinHoursDuration.GetLabel()), Int32.Parse(_spinMinutesDuration.GetLabel()), 0);
DateTime startTime = new DateTime(Int32.Parse(_spinStartYear.GetLabel()), Int32.Parse(_spinStartMonth.GetLabel()), Int32.Parse(_spinStartDay.GetLabel()), Int32.Parse(_spinStartHour.GetLabel()), Int32.Parse(_spinStartMinute.GetLabel()), 0);
ScheduleDaysOfWeek daysOfWeek = new ScheduleDaysOfWeek();
//TODO: What if we have multiple channels with the same name
Channel channel = SchedulerAgent.GetChannelByDisplayName(_channelType, _spinChannel.GetLabel());
Schedule newSchedule = null;
newSchedule = SchedulerAgent.CreateNewSchedule(_channelType, scheduleType);
newSchedule.Rules.Add(ScheduleRuleType.Channels, channel.ChannelId);
newSchedule.Rules.Add(ScheduleRuleType.ManualSchedule, startTime, new ScheduleTime(duration));
if (!_recordOnce)
{
string days = " ";
if (_mondayButton.Selected)
{
daysOfWeek = daysOfWeek | ScheduleDaysOfWeek.Mondays;
days += Utility.GetLocalizedText(TextId.Mon) + ",";
}
if (_tuesdayButton.Selected)
{
daysOfWeek = daysOfWeek | ScheduleDaysOfWeek.Tuesdays;
days += Utility.GetLocalizedText(TextId.Tue) + ",";
}
if (_wednesdayButton.Selected)
{
daysOfWeek = daysOfWeek | ScheduleDaysOfWeek.Wednesdays;
days += Utility.GetLocalizedText(TextId.Wed) + ",";
}
if (_thursdayButton.Selected)
{
daysOfWeek = daysOfWeek | ScheduleDaysOfWeek.Thursdays;
days += Utility.GetLocalizedText(TextId.Thu) + ",";
}
if (_fridayButton.Selected)
{
daysOfWeek = daysOfWeek | ScheduleDaysOfWeek.Fridays;
days += Utility.GetLocalizedText(TextId.Fri) + ",";
}
if (_saturdayButton.Selected)
{
daysOfWeek = daysOfWeek | ScheduleDaysOfWeek.Saturdays;
days += Utility.GetLocalizedText(TextId.Sat) + ",";
}
if (_sundayButton.Selected)
{
daysOfWeek = daysOfWeek | ScheduleDaysOfWeek.Sundays;
days += Utility.GetLocalizedText(TextId.Sun) + ",";
}
days = days.Remove(days.Length - 1);
newSchedule.Rules.Add(ScheduleRuleType.DaysOfWeek, daysOfWeek);
newSchedule.Name = String.Format(CultureInfo.CurrentCulture, "{0} {1} {2:t}-{3:t}", channel.DisplayName, days, startTime, startTime.Add(duration));
}
else
{
newSchedule.Name = String.Format(CultureInfo.CurrentCulture, "{0} {1:g}-{2:t}", channel.DisplayName, startTime, startTime.Add(duration));
}
//TODO: try to prevent dublicate manual schedules
//and find a better way to get the newly created "_schedule" and "_upcomingProgram"
if (newSchedule != null)
{
newSchedule.ScheduleType = scheduleType;
SchedulerAgent.SaveSchedule(newSchedule);
bool found = false;
UpcomingProgram[] _programs = SchedulerAgent.GetAllUpcomingPrograms(scheduleType, true);
foreach (UpcomingProgram _prog in _programs)
{
if (_prog.Channel.ChannelId == channel.ChannelId
&& _prog.Duration == duration
&& !found)
{
Schedule _schedule = SchedulerAgent.GetScheduleById(_prog.ScheduleId);
if (_schedule.Rules.FindRuleByType(ScheduleRuleType.ManualSchedule) != null)
{
if (_schedule.Name == newSchedule.Name)
{
if (_recordOnce
&& _prog.StartTime == startTime)
{
_upcomingProgram = _prog;
found = true;
}
else if (!_recordOnce && _schedule.Rules.FindRuleByType(ScheduleRuleType.DaysOfWeek) != null
&& _schedule.Rules.FindRuleByType(ScheduleRuleType.DaysOfWeek).Arguments[0].ToString() == daysOfWeek.ToString()
&& Convert.ToDateTime(_schedule.Rules.FindRuleByType(ScheduleRuleType.ManualSchedule).Arguments[0]) == startTime)
{
_upcomingProgram = _prog;
found = true;
}
Update(_schedule);
break;
}
}
}
}
if (!found)
{
GUIWindowManager.ShowPreviousWindow();
}
}
}
}
private void Onrecord(ScheduleType scheduleType)
{
Schedule schedule = null;
if (_upcomingProgram != null)
{
schedule = Proxies.SchedulerService.GetScheduleById(_upcomingProgram.ScheduleId).Result;
}
if (_upcomingProgram != null && schedule != null &&
schedule.ScheduleType == scheduleType) //delete schedule
{
if (_upcomingProgram.IsCancelled)
{
Proxies.SchedulerService.UncancelUpcomingProgram(_upcomingProgram.ScheduleId, _upcomingProgram.GuideProgramId, _upcomingProgram.Channel.ChannelId, _upcomingProgram.StartTime).Wait();
try
{
//refresh _upcomingProgram
_upcomingProgram = Proxies.SchedulerService.GetUpcomingPrograms(schedule, true).Result[0];
}
catch { }
}
else
{
if (_upcomingProgram.IsPartOfSeries)
{
GUIDialogYesNo dlgYesNo = (GUIDialogYesNo)GUIWindowManager.GetWindow((int)GUIWindow.Window.WINDOW_DIALOG_YES_NO);
if (dlgYesNo != null)
{
dlgYesNo.SetHeading(Utility.GetLocalizedText(TextId.DeleteEntireSchedule));
dlgYesNo.SetLine(1, "\"" + schedule.Name + "\"");
dlgYesNo.SetLine(2, Utility.GetLocalizedText(TextId.AreYouSure));
dlgYesNo.SetLine(3, String.Empty);
dlgYesNo.SetDefaultToYes(false);
dlgYesNo.DoModal(GUIWindowManager.ActiveWindow);
if (dlgYesNo.IsConfirmed)
{
Proxies.SchedulerService.DeleteSchedule(schedule.ScheduleId).Wait();
_upcomingProgram = null;
}
}
}
else
{
Proxies.SchedulerService.DeleteSchedule(_upcomingProgram.ScheduleId).Wait();
_upcomingProgram = null;
}
}
}
else//create new schedule
{
TimeSpan duration = new TimeSpan(Int32.Parse(_spinHoursDuration.GetLabel()), Int32.Parse(_spinMinutesDuration.GetLabel()), 0);
DateTime startTime = new DateTime(Int32.Parse(_spinStartYear.GetLabel()), Int32.Parse(_spinStartMonth.GetLabel()), Int32.Parse(_spinStartDay.GetLabel()), Int32.Parse(_spinStartHour.GetLabel()), Int32.Parse(_spinStartMinute.GetLabel()), 0);
ScheduleDaysOfWeek daysOfWeek = new ScheduleDaysOfWeek();
//TODO: What if we have multiple channels with the same name
Channel channel = Proxies.SchedulerService.GetChannelByDisplayName(_channelType, _spinChannel.GetLabel()).Result;
Schedule newSchedule = null;
newSchedule = Proxies.SchedulerService.CreateNewSchedule(_channelType, scheduleType).Result;
newSchedule.Rules.Add(ScheduleRuleType.Channels, channel.ChannelId);
newSchedule.Rules.Add(ScheduleRuleType.ManualSchedule, startTime, new ScheduleTime(duration));
if (!_recordOnce)
{
string days = " ";
if (_mondayButton.Selected)
{
daysOfWeek = daysOfWeek | ScheduleDaysOfWeek.Mondays;
days += Utility.GetLocalizedText(TextId.Mon) + ",";
}
if (_tuesdayButton.Selected)
{
daysOfWeek = daysOfWeek | ScheduleDaysOfWeek.Tuesdays;
days += Utility.GetLocalizedText(TextId.Tue) + ",";
}
if (_wednesdayButton.Selected)
{
daysOfWeek = daysOfWeek | ScheduleDaysOfWeek.Wednesdays;
days += Utility.GetLocalizedText(TextId.Wed) + ",";
}
if (_thursdayButton.Selected)
{
daysOfWeek = daysOfWeek | ScheduleDaysOfWeek.Thursdays;
days += Utility.GetLocalizedText(TextId.Thu) + ",";
}
if (_fridayButton.Selected)
{
daysOfWeek = daysOfWeek | ScheduleDaysOfWeek.Fridays;
days += Utility.GetLocalizedText(TextId.Fri) + ",";
}
if (_saturdayButton.Selected)
{
daysOfWeek = daysOfWeek | ScheduleDaysOfWeek.Saturdays;
days += Utility.GetLocalizedText(TextId.Sat) + ",";
}
if (_sundayButton.Selected)
{
daysOfWeek = daysOfWeek | ScheduleDaysOfWeek.Sundays;
days += Utility.GetLocalizedText(TextId.Sun) + ",";
}
days = days.Remove(days.Length - 1);
newSchedule.Rules.Add(ScheduleRuleType.DaysOfWeek, daysOfWeek);
newSchedule.Name = String.Format(CultureInfo.CurrentCulture, "{0} {1} {2:t}-{3:t}", channel.DisplayName, days, startTime, startTime.Add(duration));
}
else
{
newSchedule.Name = String.Format(CultureInfo.CurrentCulture, "{0} {1:g}-{2:t}", channel.DisplayName, startTime, startTime.Add(duration));
}
//TODO: try to prevent dublicate manual schedules
//and find a better way to get the newly created "_schedule" and "_upcomingProgram"
if (newSchedule != null)
{
newSchedule.ScheduleType = scheduleType;
Proxies.SchedulerService.SaveSchedule(newSchedule).Wait();
bool found = false;
var _programs = Proxies.SchedulerService.GetAllUpcomingPrograms(scheduleType, true).Result;
foreach (UpcomingProgram _prog in _programs)
{
if (_prog.Channel.ChannelId == channel.ChannelId &&
_prog.Duration == duration &&
!found)
{
Schedule _schedule = Proxies.SchedulerService.GetScheduleById(_prog.ScheduleId).Result;
if (_schedule.Rules.FindRuleByType(ScheduleRuleType.ManualSchedule) != null)
{
if (_schedule.Name == newSchedule.Name)
{
if (_recordOnce &&
_prog.StartTime == startTime)
{
_upcomingProgram = _prog;
found = true;
}
else if (!_recordOnce && _schedule.Rules.FindRuleByType(ScheduleRuleType.DaysOfWeek) != null &&
_schedule.Rules.FindRuleByType(ScheduleRuleType.DaysOfWeek).Arguments[0].ToString() == daysOfWeek.ToString() &&
Convert.ToDateTime(_schedule.Rules.FindRuleByType(ScheduleRuleType.ManualSchedule).Arguments[0]) == startTime)
{
_upcomingProgram = _prog;
found = true;
}
Update(_schedule);
break;
}
}
}
}
if (!found)
{
GUIWindowManager.ShowPreviousWindow();
}
}
}
}
private string BuildManualScheduleName(string channelDisplayName, DateTime startTime, TimeSpan duration, ScheduleDaysOfWeek daysOfWeek)
{
StringBuilder name = new StringBuilder();
if (daysOfWeek == ScheduleDaysOfWeek.None)
{
name.AppendFormat("{0} {1:g} ({2:00}:{3:00})", channelDisplayName, startTime, duration.Hours, duration.Minutes);
}
else
{
name.AppendFormat("{0} ", channelDisplayName);
if ((daysOfWeek & ScheduleDaysOfWeek.Mondays) != 0)
{
name.Append("Mo,");
}
if ((daysOfWeek & ScheduleDaysOfWeek.Tuesdays) != 0)
{
name.Append("Tu,");
}
if ((daysOfWeek & ScheduleDaysOfWeek.Wednesdays) != 0)
{
name.Append("We,");
}
if ((daysOfWeek & ScheduleDaysOfWeek.Thursdays) != 0)
{
name.Append("Th,");
}
if ((daysOfWeek & ScheduleDaysOfWeek.Fridays) != 0)
{
name.Append("Fr,");
}
if ((daysOfWeek & ScheduleDaysOfWeek.Saturdays) != 0)
{
name.Append("Sa,");
}
if ((daysOfWeek & ScheduleDaysOfWeek.Sundays) != 0)
{
name.Append("Su,");
}
name.Remove(name.Length - 1, 1);
name.AppendFormat(" at {0:00}:{1:00} ({2:00}:{3:00})",
startTime.TimeOfDay.Hours, startTime.TimeOfDay.Minutes, duration.Hours, duration.Minutes);
}
return name.ToString();
}
public void UpdateManualSchedule(Guid channelId, string channelDisplayName, DateTime startTime, TimeSpan duration, ScheduleDaysOfWeek daysOfWeek)
{
ScheduleRules rules = new ScheduleRules();
rules.Add(ScheduleRuleType.Channels, channelId);
rules.Add(ScheduleRuleType.ManualSchedule, startTime, new ScheduleTime(duration));
if (daysOfWeek != ScheduleDaysOfWeek.None)
{
rules.Add(ScheduleRuleType.DaysOfWeek, daysOfWeek);
}
_model.Schedule.Name = BuildManualScheduleName(channelDisplayName, startTime, duration, daysOfWeek);
_model.Schedule.Rules = rules;
}
private void ShowRulesInUI()
{
_onDateDateTimePicker.Checked = false;
_descriptionOrAnyComboBox.SelectedIndex = 0;
int typeIndex;
_titleTextBox.Text = _controller.GetTitleRuleText(out typeIndex);
_titleRuleTypeComboBox.SelectedIndex = typeIndex;
_subTitleTextBox.Text = _controller.GetSubTitleRuleText(out typeIndex);
_subTitleRuleTypeComboBox.SelectedIndex = typeIndex;
_episodeNumberTextBox.Text = _controller.GetEpisodeNumberRuleText(out typeIndex);
_episodeNumberRuleTypeComboBox.SelectedIndex = typeIndex;
bool isProgramInfo;
_descriptionOrAnyTextBox.Text = _controller.GetDescriptionOrProgramInfoRuleText(out isProgramInfo);
_descriptionOrAnyComboBox.SelectedIndex = isProgramInfo ? 0 : 1;
foreach (ScheduleRule rule in _model.Schedule.Rules)
{
switch (rule.Type)
{
case ScheduleRuleType.NotOnChannels:
if (!_manualScheduleGroupBox.Visible)
{
goto case ScheduleRuleType.Channels;
}
break;
case ScheduleRuleType.Channels:
_tvChannelsListBox.Items.Clear();
foreach (Guid channelId in rule.Arguments)
{
ChannelListItem item = FindChannelItem(_channelComboBox, channelId);
if (item == null &&
_model.AllChannels.ContainsKey(channelId))
{
item = new ChannelListItem(_model.AllChannels[channelId]);
}
if (item != null)
{
_tvChannelsListBox.Items.Add(item);
}
}
if (_manualScheduleGroupBox.Visible &&
rule.Arguments.Count > 0)
{
Guid channelId = (Guid)rule.Arguments[0];
SelectGroupWithChannel(_manualChannelGroupComboBox, channelId);
_manualChannelComboBox.SelectedItem = FindChannelItem(_manualChannelComboBox, channelId);
}
_notInChannelsRadioButton.Checked = (rule.Type == ScheduleRuleType.NotOnChannels);
break;
case ScheduleRuleType.OnDate:
_onDateLabel.Text = _onDateLabelText;
_manualDateTimeLabel.Text = _onDateLabelText;
_onDateDateTimePicker.Checked = true;
_onDateDateTimePicker.Value = (DateTime)rule.Arguments[0];
_scheduleDaysOfWeekControl.ScheduleDaysOfWeek = ScheduleDaysOfWeek.None;
break;
case ScheduleRuleType.DaysOfWeek:
_onDateLabel.Text = _fromDateLabelText;
_manualDateTimeLabel.Text = _fromDateLabelText;
ScheduleDaysOfWeek scheduleDaysOfWeek = (ScheduleDaysOfWeek)rule.Arguments[0];
_scheduleDaysOfWeekControl.ScheduleDaysOfWeek = scheduleDaysOfWeek;
_manualScheduleDaysOfWeekControl.ScheduleDaysOfWeek = scheduleDaysOfWeek;
if (rule.Arguments.Count > 1)
{
_onDateDateTimePicker.Checked = true;
_onDateDateTimePicker.Value = (DateTime)rule.Arguments[1];
}
else
{
_onDateDateTimePicker.Checked = false;
_onDateDateTimePicker.Value = DateTime.Today;
}
break;
case ScheduleRuleType.AroundTime:
_aroundCheckBox.Checked = true;
ScheduleTime aroundTime = (ScheduleTime)rule.Arguments[0];
_aroundDateTimePicker.Value = DateTime.Today.AddTicks(aroundTime.Ticks);
break;
case ScheduleRuleType.StartingBetween:
_betweenCheckBox.Checked = true;
ScheduleTime fromTime = (ScheduleTime)rule.Arguments[0];
ScheduleTime toTime = (ScheduleTime)rule.Arguments[1];
_betweenFromDateTimePicker.Value = DateTime.Today.AddTicks(fromTime.Ticks);
_betweenToDateTimePicker.Value = DateTime.Today.AddTicks(toTime.Ticks);
break;
case ScheduleRuleType.CategoryEquals:
case ScheduleRuleType.CategoryDoesNotEqual:
foreach (string category in rule.Arguments)
{
_categoriesListBox.Items.Add(category);
}
_notInCategoriesRadioButton.Checked = (rule.Type == ScheduleRuleType.CategoryDoesNotEqual);
break;
case ScheduleRuleType.DirectedBy:
foreach (string director in rule.Arguments)
{
_directorsListBox.Items.Add(director);
}
break;
case ScheduleRuleType.WithActor:
foreach (string actor in rule.Arguments)
{
_actorsListBox.Items.Add(actor);
}
break;
case ScheduleRuleType.NewEpisodesOnly:
_newEpisodesOnlyCheckBox.Checked = (bool)rule.Arguments[0];
break;
case ScheduleRuleType.NewTitlesOnly:
_newTitlesOnlyCheckBox.Checked = (bool)rule.Arguments[0];
break;
case ScheduleRuleType.SkipRepeats:
_skipRepeatsCheckBox.Checked = (bool)rule.Arguments[0];
break;
case ScheduleRuleType.ManualSchedule:
DateTime manualDateTime = (DateTime)rule.Arguments[0];
ScheduleTime manualDuration = (ScheduleTime)rule.Arguments[1];
_manualDatePicker.Value = manualDateTime.Date;
_manualTimePicker.Value = DateTime.Today.Add(manualDateTime.TimeOfDay);
_manualDurationDateTimePicker.Value = DateTime.Today.AddTicks(manualDuration.Ticks);
break;
}
}
RefreshListBoxAllLabels();
}
public static List<DayOfWeek> GetDaysOfWeek(ScheduleDaysOfWeek scheduleDaysOfWeek)
{
var daysOfWeek = new List<DayOfWeek>();
if ((scheduleDaysOfWeek & ScheduleDaysOfWeek.Mondays) != 0)
{
daysOfWeek.Add(DayOfWeek.Monday);
}
if ((scheduleDaysOfWeek & ScheduleDaysOfWeek.Tuesdays) != 0)
{
daysOfWeek.Add(DayOfWeek.Tuesday);
}
if ((scheduleDaysOfWeek & ScheduleDaysOfWeek.Wednesdays) != 0)
{
daysOfWeek.Add(DayOfWeek.Wednesday);
}
if ((scheduleDaysOfWeek & ScheduleDaysOfWeek.Thursdays) != 0)
{
daysOfWeek.Add(DayOfWeek.Thursday);
}
if ((scheduleDaysOfWeek & ScheduleDaysOfWeek.Fridays) != 0)
{
daysOfWeek.Add(DayOfWeek.Friday);
}
if ((scheduleDaysOfWeek & ScheduleDaysOfWeek.Saturdays) != 0)
{
daysOfWeek.Add(DayOfWeek.Saturday);
}
if ((scheduleDaysOfWeek & ScheduleDaysOfWeek.Sundays) != 0)
{
daysOfWeek.Add(DayOfWeek.Sunday);
}
return daysOfWeek;
}
