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