private static string GetContainsExpression(List <ScheduleRule> 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 "); } if (expression.Length >= 4) { 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()); }
private static void AppendORableRule(List <ScheduleRule> 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; } } }
public static string GenerateRrule(ScheduleRuleType scheduleRuleType, DaysOfWeek daysOfWeek, DateTime until) { var rrule = new StringBuilder(); rrule.Append("RRULE:"); if (scheduleRuleType == ScheduleRuleType.ByDayOfWeek || scheduleRuleType == ScheduleRuleType.ByDayOfWeekEveryOtherWeek) { rrule.Append("FREQ=WEEKLY;"); } else { throw new Exception($"Unable to parse ScheduleRuleType {scheduleRuleType} to RRULE"); } if (scheduleRuleType == ScheduleRuleType.ByDayOfWeekEveryOtherWeek) { rrule.Append("INTERVAL=2;"); } var byDayString = ConvertDaysOfWeekToRRULEString(daysOfWeek); rrule.Append($"BYDAY={byDayString};"); rrule.Append($"UNTIL={until.ToString("yyyyMMdd")}"); return(rrule.ToString()); }
private static string GetTitleRuleExpression(List <ScheduleRule> rules, ScheduleRuleType equalsRule, ScheduleRuleType startsWithRule, ScheduleRuleType containsRule, ScheduleRuleType doesNotContainRule, out int typeIndex) { string expression = GetContainsExpression(rules, containsRule, doesNotContainRule); if (String.IsNullOrEmpty(expression)) { typeIndex = TitleRuleTypeIndex.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 = TitleRuleTypeIndex.StartsWith; break; } } } else { typeIndex = TitleRuleTypeIndex.Contains; } return(expression); }
/// <summary> /// Construct a schedule rule with a given type and optional arguments. /// </summary> /// <param name="type">The type of the rule.</param> /// <param name="args">Optional arguments to the rule.</param> public ScheduleRule(ScheduleRuleType type, params object[] args) { this.Type = type; this.Arguments = new List <object>(); foreach (object arg in args) { this.Arguments.Add(arg); } }
/// <summary> /// Construct a schedule rule with a given type and optional arguments. /// </summary> /// <param name="type">The type of the rule.</param> /// <param name="args">Optional arguments to the rule.</param> public ScheduleRule(ScheduleRuleType type, params object[] args) { this.Type = type; this.Arguments = new List<object>(); foreach (object arg in args) { this.Arguments.Add(arg); } }
private static void AppendStringArgumentsRule(List <ScheduleRule> 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); } }
private static void AppendContainsRule(List <ScheduleRule> rules, ScheduleRuleType containsRule, ScheduleRuleType doesNotContainRule, string expression) { expression = expression.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; } } }
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; }
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(); }
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; } } }
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); } }
/// <summary> /// Find a rule with a given type. /// </summary> /// <param name="scheduleRules">The schedule rules collection.</param> /// <param name="ruleType">The type to search for.</param> /// <returns>The schedule rule of the given type, or null if no rule of the given type was found.</returns> public static ScheduleRule FindRuleByType(this List <ScheduleRule> scheduleRules, ScheduleRuleType ruleType) { return(scheduleRules.FirstOrDefault(r => r.Type == ruleType)); }
/// <summary> /// Add a new rule (with optional arguments). /// </summary> /// <param name="scheduleRules">The schedule rules collection.</param> /// <param name="type">The type of the rule to add.</param> /// <param name="args">Optional arguments to the rule.</param> public static void Add(this List <ScheduleRule> scheduleRules, ScheduleRuleType type, params object[] args) { scheduleRules.Add(new ScheduleRule(type, args)); }