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); } }