public void AppendAroundTimeRule(ScheduleRules rules, DateTime? aroundTime)
{
if (aroundTime.HasValue)
{
rules.Add(ScheduleRuleType.AroundTime,
new ScheduleTime(aroundTime.Value.Hour, aroundTime.Value.Minute, aroundTime.Value.Second));
}
}
public void AppendChannelsRule(ScheduleRules rules, bool notOnChannels, IList channelIds)
{
ScheduleRule channelsRule = new ScheduleRule(notOnChannels ? ScheduleRuleType.NotOnChannels : ScheduleRuleType.Channels);
foreach (Guid channel in channelIds)
{
channelsRule.Arguments.Add(channel);
}
if (channelsRule.Arguments.Count > 0)
{
rules.Add(channelsRule);
}
}
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);
}
}
}
public static void AppendEpisodeTitleRule(ScheduleRules rules, TextRuleType textRuleType, string text)
{
text = (text ?? String.Empty).Trim();
if (!String.IsNullOrEmpty(text))
{
switch (textRuleType)
{
case TextRuleType.Equals:
AppendORableRule(rules, ScheduleRuleType.SubTitleEquals, text);
break;
case TextRuleType.StartsWith:
AppendORableRule(rules, ScheduleRuleType.SubTitleStartsWith, text);
break;
case TextRuleType.Contains:
AppendContainsRule(rules, ScheduleRuleType.SubTitleContains, ScheduleRuleType.SubTitleDoesNotContain, text);
break;
}
}
}
private static string GetContainsExpression(ScheduleRules rules, ScheduleRuleType containsRule, ScheduleRuleType doesNotContainRule)
{
StringBuilder expression = new StringBuilder();
foreach (ScheduleRule rule in rules)
{
if (rule.Type == containsRule)
{
if (expression.Length > 0)
{
expression.Append(" AND ");
}
foreach (string arg in rule.Arguments)
{
expression.Append(arg).Append(" OR ");
}
expression.Remove(expression.Length - 4, 4);
}
else if (rule.Type == doesNotContainRule)
{
if (expression.Length > 0)
{
expression.Append(" ");
}
expression.Append("NOT ").Append(rule.Arguments[0]);
}
}
return expression.ToString();
}
public static void AppendAroundTimeRule(ScheduleRules rules, DateTime aroundTime)
{
rules.Add(ScheduleRuleType.AroundTime,
new ScheduleTime(aroundTime.Hour, aroundTime.Minute, aroundTime.Second));
}
private static void AppendORableRule(ScheduleRules rules, ScheduleRuleType rule, string expression)
{
expression = expression.Trim();
if (!String.IsNullOrEmpty(expression))
{
List<object> arguments = new List<object>();
int index = 0;
while (index < expression.Length)
{
int operatorIndex;
int nextIndex;
Operator op = GetNextOperator(expression, index, out operatorIndex, out nextIndex);
if (op == Operator.None)
{
arguments.Add(expression.Substring(index).Trim());
rules.Add(rule, arguments.ToArray());
break;
}
string fragment = expression.Substring(index, operatorIndex - index).Trim();
if (fragment.Length > 0
&& fragment != "AND"
&& fragment != "OR")
{
arguments.Add(fragment);
}
index = nextIndex;
}
}
}
private static void AppendContainsRule(ScheduleRules rules, ScheduleRuleType containsRule,
ScheduleRuleType doesNotContainRule, string expression)
{
expression = (expression ?? String.Empty).Trim();
if (!String.IsNullOrEmpty(expression))
{
List<object> arguments = new List<object>();
bool lastOperatorWasNot = false;
int index = 0;
while (index < expression.Length)
{
int operatorIndex;
int nextIndex;
Operator op = GetNextOperator(expression, index, out operatorIndex, out nextIndex);
if (op == Operator.None)
{
arguments.Add(expression.Substring(index).Trim());
rules.Add(lastOperatorWasNot ? doesNotContainRule : containsRule, arguments.ToArray());
break;
}
string fragment = expression.Substring(index, operatorIndex - index).Trim();
if (fragment.Length > 0
&& fragment != "AND"
&& fragment != "OR")
{
if (lastOperatorWasNot)
{
rules.Add(doesNotContainRule, fragment);
}
else
{
arguments.Add(fragment);
if (op != Operator.Or)
{
rules.Add(containsRule, arguments.ToArray());
arguments.Clear();
}
}
}
lastOperatorWasNot = (op == Operator.Not);
index = nextIndex;
}
}
}
public static string GetEpisodeNumberRuleText(ScheduleRules rules)
{
ScheduleRule rule = rules.FindRuleByType(ScheduleRuleType.EpisodeNumberEquals);
if (rule != null)
{
return JoinORedArguments(rule.Arguments);
}
return String.Empty;
}
public static void AppendStartingBetweenRule(ScheduleRules rules, DateTime lowerTime, DateTime upperTime)
{
rules.Add(ScheduleRuleType.StartingBetween,
new ScheduleTime(lowerTime.Hour, lowerTime.Minute, lowerTime.Second),
new ScheduleTime(upperTime.Hour, upperTime.Minute, upperTime.Second));
}
public void AppendSkipRepeatsRule(ScheduleRules rules, bool skipRepeats)
{
if (skipRepeats)
{
rules.Add(ScheduleRuleType.SkipRepeats, true);
}
}
public static void AppendDescriptionRule(ScheduleRules rules, string text)
{
AppendContainsRule(rules, ScheduleRuleType.DescriptionContains, ScheduleRuleType.DescriptionDoesNotContain, text);
}
public void AppendCategoriesRule(ScheduleRules rules, bool doNotEqual, IList categories)
{
AppendStringArgumentsRule(rules, doNotEqual ? ScheduleRuleType.CategoryDoesNotEqual : ScheduleRuleType.CategoryEquals, categories);
}
public void AppendTitleRule(ScheduleRules rules, int titleRuleTypeIndex, string text)
{
text = text.Trim();
if (!String.IsNullOrEmpty(text))
{
switch (titleRuleTypeIndex)
{
case TitleRuleTypeIndex.Equals:
AppendORableRule(rules, ScheduleRuleType.TitleEquals, text);
break;
case TitleRuleTypeIndex.StartsWith:
AppendORableRule(rules, ScheduleRuleType.TitleStartsWith, text);
break;
case TitleRuleTypeIndex.Contains:
AppendContainsRule(rules, ScheduleRuleType.TitleContains, ScheduleRuleType.TitleDoesNotContain, text);
break;
}
}
}
private static void AppendStringArgumentsRule(ScheduleRules rules, ScheduleRuleType ruleType, IList arguments)
{
ScheduleRule rule = new ScheduleRule(ruleType);
foreach (string arg in arguments)
{
rule.Arguments.Add(arg);
}
if (rule.Arguments.Count > 0)
{
rules.Add(rule);
}
}
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;
}
public void AppendWithActorRule(ScheduleRules rules, IList actors)
{
AppendStringArgumentsRule(rules, ScheduleRuleType.WithActor, actors);
}
private static string GetTitleRuleExpression(ScheduleRules rules, ScheduleRuleType equalsRule, ScheduleRuleType startsWithRule,
ScheduleRuleType containsRule, ScheduleRuleType doesNotContainRule, out TextRuleType typeIndex)
{
string expression = GetContainsExpression(rules, containsRule, doesNotContainRule);
if (String.IsNullOrEmpty(expression))
{
typeIndex = TextRuleType.Equals;
foreach (ScheduleRule rule in rules)
{
if (rule.Type == equalsRule)
{
expression = JoinORedArguments(rule.Arguments);
break;
}
else if (rule.Type == startsWithRule)
{
expression = JoinORedArguments(rule.Arguments);
typeIndex = TextRuleType.StartsWith;
break;
}
}
}
else
{
typeIndex = TextRuleType.Contains;
}
return expression;
}
public void AppendDirectedByRule(ScheduleRules rules, IList directors)
{
AppendStringArgumentsRule(rules, ScheduleRuleType.DirectedBy, directors);
}
public static void AppendProgramInfoRule(ScheduleRules rules, string text)
{
AppendContainsRule(rules, ScheduleRuleType.ProgramInfoContains, ScheduleRuleType.ProgramInfoDoesNotContain, text);
}
public void AppendNewTitlesOnlyRule(ScheduleRules rules, bool newTitlesOnly)
{
if (newTitlesOnly)
{
rules.Add(ScheduleRuleType.NewTitlesOnly, true);
}
}
