private bool CanSkipRule(Rule rule)
{
if (rule.Actions == null)
{
this.context.TraceDebug <string>("Skipping rule with no actions: \"{0}.\"", rule.Name);
return(true);
}
if (!this.context.IsOof && RuleLoader.IsOofRule(rule))
{
this.context.TraceDebug <string>("Skipping OOF rule: \"{0}.\"", rule.Name);
return(true);
}
if ((rule.StateFlags & RuleStateFlags.TempDisabled) != (RuleStateFlags)0)
{
if (!this.context.ShouldExecuteDisabledAndInErrorRules)
{
this.context.TraceDebug <string>("Skipping temporarily disabled rule: \"{0}.\"", rule.Name);
return(true);
}
this.context.TraceDebug <string>("Including temporarily disabled rule: \"{0}\" for test message", rule.Name);
}
if ((rule.StateFlags & RuleStateFlags.LegacyOofRule) != (RuleStateFlags)0)
{
this.context.TraceDebug <string>("Skipping legacy OOF rule \"{0}.\"", rule.Name);
return(true);
}
if ((rule.StateFlags & RuleStateFlags.Enabled) == (RuleStateFlags)0 && (rule.StateFlags & RuleStateFlags.OnlyWhenOOFEx) == (RuleStateFlags)0)
{
if (!this.context.ShouldExecuteDisabledAndInErrorRules)
{
this.context.TraceDebug <string>("Skipping disabled rule \"{0}.\"", rule.Name);
return(true);
}
this.context.TraceDebug <string>("Including disabled rule: \"{0}\" for test message", rule.Name);
}
if ((rule.StateFlags & RuleStateFlags.Error) != (RuleStateFlags)0)
{
if (!this.context.ShouldExecuteDisabledAndInErrorRules)
{
this.context.TraceDebug <string>("Skipping rule \"{0},\" it is in error.", rule.Name);
return(true);
}
this.context.TraceDebug <string>("Including in error rule: \"{0}\" for test message", rule.Name);
}
if (this.IsSafeMessage() && RuleLoader.IsJunkEmailRule(rule))
{
this.context.TraceDebug <string>("Skipping junk email rule \"{0}\" for this trusted message.", rule.Name);
return(true);
}
return(false);
}
internal static bool HasOofRule(List <Rule> rules)
{
if (rules == null)
{
return(false);
}
foreach (Rule rule in rules)
{
if (RuleLoader.IsOofRule(rule))
{
return(true);
}
}
return(false);
}
private void EnforceRulesQuota(List <Rule> rules)
{
int num = -1;
Folder currentFolder = this.context.CurrentFolder;
bool flag = false;
ulong rulesQuota = this.GetRulesQuota();
object obj = currentFolder.TryGetProperty(FolderSchema.FolderRulesSize);
ulong num2;
if (obj is PropertyError)
{
num2 = this.GetFolderRulesSize(currentFolder);
}
else
{
num2 = (ulong)((long)((int)obj));
}
for (int i = rules.Count - 1; i >= 0; i--)
{
if (num2 < rulesQuota)
{
return;
}
Rule rule = rules[i];
if (!rule.IsExtended && !RuleLoader.IsDisabled(rule))
{
if (!flag && RuleLoader.IsOofRule(rule))
{
if (num == -1)
{
num = i;
}
}
else
{
this.context.TraceDebug <string>("EnforceRulesQuota. Disabling and mark in error rule {0}", rule.Name);
this.context.DisableAndMarkRuleInError(rule, rule.Actions[0].ActionType, 0, DeferredError.RuleError.FolderOverQuota);
}
num2 = this.GetFolderRulesSize(currentFolder);
}
if (i == 0 && !flag && num2 >= rulesQuota && num != -1)
{
flag = true;
i = num + 1;
}
}
}
public IEnumerator <Rule> GetEnumerator()
{
foreach (Rule rule in this.rules)
{
if (this.evaluationResult.ExitExecution)
{
if (RuleLoader.IsOofRule(rule))
{
yield return(rule);
}
}
else
{
yield return(rule);
}
}
yield break;
}
private void CreateWorkItemForForward(FolderEvaluationResult result, RuleAction.Forward action, int actionIndex)
{
if (ObjectClass.IsDsn(this.context.Message.ClassName) || ObjectClass.IsMdn(this.context.Message.ClassName))
{
this.context.TraceDebug("Do not forward for Dsn or Mdn messages");
return;
}
if (this.context.Message.Sensitivity == Sensitivity.Private)
{
this.context.TraceDebug("Do not forward private message");
return;
}
object obj = this.context.Message.TryGetProperty(MessageItemSchema.RecipientReassignmentProhibited);
if (obj is bool && (bool)obj)
{
this.context.TraceDebug("Do not forward message is recipient reassignment is prohibited");
return;
}
if ((this.context.Message.AutoResponseSuppress & AutoResponseSuppress.AutoReply) != AutoResponseSuppress.None && RuleLoader.IsOofRule(this.context.CurrentRule))
{
this.context.TraceDebug("Do not forward message is auto reply is suppressed");
return;
}
if (RuleUtil.IsNullOrEmpty(action.Recipients))
{
this.context.TraceError("Forward recipient list is empty");
return;
}
if (!this.context.LimitChecker.CheckAndIncrementForwardeeCount(action.Recipients.Length))
{
this.context.TraceDebug(string.Concat(new object[]
{
"Rule ",
this.context.CurrentRule.Name,
" is forwarding to ",
action.Recipients.Length,
" additional recipients, which reached the accumulated forwardee limit, evaluation skipped."
}));
return;
}
result.AddWorkItem(new ForwardWorkItem(this.context, action.Recipients, action.Flags, actionIndex));
}
