public void Execute(ExecutionStage stage)
{
foreach (WorkItem workItem in this.workItems)
{
if ((stage & workItem.Stage) != (ExecutionStage)0)
{
string stageDescription = FolderEvaluationResult.GetStageDescription(stage);
try
{
this.context.CurrentRule = workItem.Rule;
RuleUtil.FaultInjection((FaultInjectionLid)4175834429U);
workItem.Execute();
this.context.LogWorkItemExecution(workItem);
}
catch (InvalidRuleException exception)
{
this.context.RecordError(exception, stageDescription);
this.context.DisableAndMarkRuleInError(workItem.Rule, workItem.Rule.Actions[workItem.ActionIndex].ActionType, workItem.ActionIndex, DeferredError.RuleError.Execution);
}
catch (StoragePermanentException exception2)
{
this.context.RecordError(exception2, stageDescription);
}
catch (ExchangeDataException exception3)
{
this.context.RecordError(exception3, stageDescription);
}
catch (MapiPermanentException exception4)
{
this.context.RecordError(exception4, stageDescription);
}
catch (DataValidationException exception5)
{
this.context.RecordError(exception5, stageDescription);
}
finally
{
this.context.CurrentRule = null;
}
}
}
}
public bool CompareAddresses(object messageValue, object ruleValue)
{
ProxyAddress proxyAddressFromSearchKey = RuleUtil.GetProxyAddressFromSearchKey(messageValue);
ProxyAddress proxyAddressFromSearchKey2 = RuleUtil.GetProxyAddressFromSearchKey(ruleValue);
if (proxyAddressFromSearchKey2 == null || proxyAddressFromSearchKey2 is InvalidProxyAddress || string.IsNullOrEmpty(proxyAddressFromSearchKey2.ValueString))
{
string recipient = ServerStrings.Null;
if (proxyAddressFromSearchKey2 != null)
{
recipient = proxyAddressFromSearchKey2.ToString();
}
this.DisableAndMarkRuleInError(this.CurrentRule, RuleAction.Type.OP_INVALID, 0, DeferredError.RuleError.Parsing);
this.RecordError(ServerStrings.FolderRuleErrorInvalidRecipient(recipient));
return(false);
}
this.TraceDebug <ProxyAddress, ProxyAddress>("Comparing recipients, message address {0}, rule address {1}", proxyAddressFromSearchKey, proxyAddressFromSearchKey2);
RuleUtil.FaultInjection((FaultInjectionLid)4257530192U);
return(RuleUtil.IsSameUser(this, this.RecipientCache, proxyAddressFromSearchKey, proxyAddressFromSearchKey2));
}
private FolderEvaluationResult EvaluateRulesOnCurrentFolder()
{
FolderEvaluationResult folderEvaluationResult = null;
string stage = ServerStrings.FolderRuleStageLoading;
try
{
RuleUtil.FaultInjection((FaultInjectionLid)3353750845U);
List <Rule> list = this.context.LoadRules();
if (list == null)
{
return(null);
}
stage = ServerStrings.FolderRuleStageEvaluation;
folderEvaluationResult = new FolderEvaluationResult(this.context, list);
if (this.context.SharedPropertiesBetweenAgents == null)
{
this.context.SharedPropertiesBetweenAgents = new Dictionary <PropertyDefinition, object>();
}
foreach (Rule rule in folderEvaluationResult.Rules)
{
this.context.CurrentRule = rule;
if (this.EvaluateRule(rule, folderEvaluationResult))
{
if ((rule.StateFlags & RuleStateFlags.ExitAfterExecution) != (RuleStateFlags)0)
{
this.context.TraceDebug <string>("Encountered exit level rule {0} ", rule.Name);
folderEvaluationResult.ExitExecution = true;
this.context.SharedPropertiesBetweenAgents[ItemSchema.IsStopProcessingRuleApplicable] = true;
}
if (RuleLoader.IsJunkEmailRule(rule))
{
this.context.TraceDebug <string>("Processed junk email rule {0} ", rule.Name);
this.context.SharedPropertiesBetweenAgents[SharedProperties.ItemMovedByJunkMailRule] = folderEvaluationResult.IsMessageMoved;
break;
}
if (RuleLoader.IsNeverClutterOverrideRule(rule))
{
this.context.SharedPropertiesBetweenAgents[ItemSchema.InferenceNeverClutterOverrideApplied] = true;
}
this.context.SharedPropertiesBetweenAgents[ItemSchema.ItemMovedByConversationAction] = this.context.ShouldSkipMoveRule;
this.context.SharedPropertiesBetweenAgents[ItemSchema.ItemMovedByRule] = folderEvaluationResult.IsMessageMoved;
if (!folderEvaluationResult.ShouldContinue)
{
this.context.TraceDebug("Terminate rules processing on current folder");
break;
}
}
}
this.context.CurrentRule = null;
}
catch (StoragePermanentException exception)
{
this.context.RecordError(exception, stage);
}
catch (ExchangeDataException exception2)
{
this.context.RecordError(exception2, stage);
}
catch (MapiPermanentException exception3)
{
this.context.RecordError(exception3, stage);
}
catch (DataValidationException exception4)
{
this.context.RecordError(exception4, stage);
}
finally
{
this.context.CurrentRule = null;
}
return(folderEvaluationResult);
}
private bool EvaluateRule(Rule rule, FolderEvaluationResult result)
{
if (rule == null)
{
throw new ArgumentNullException("rule");
}
if (result == null)
{
throw new ArgumentNullException("result");
}
if (rule.Actions == null)
{
throw new ArgumentException("Rule.Actions must not be null.");
}
this.context.CurrentRule = rule;
this.context.NestedLevel = 0;
this.context.TraceDebug <string>("Evaluate rule {0}", rule.Name);
int i = 0;
bool result2;
try
{
RuleUtil.FaultInjection((FaultInjectionLid)3102092605U);
if (!RestrictionEvaluator.Evaluate(rule.Condition, this.context))
{
result2 = false;
}
else
{
this.context.TraceDebug <string>("Rule {0} evaluated to true", rule.Name);
if (this.context.HasRuleFiredBefore(rule))
{
this.context.TraceDebug <string>("Rule history loop detected on rule {0}", rule.Name);
result2 = false;
}
else
{
while (i < rule.Actions.Length)
{
RuleAction ruleAction = rule.Actions[i];
if (ruleAction == null)
{
this.context.TraceDebug <string, int>("For rule \"{0}\", action at index {1} is null.", rule.Name, i);
}
else
{
this.CreateWorkItemForAction(result, ruleAction, i++);
if (!result.ShouldContinue)
{
this.context.TraceDebug <Type>("Stop evaluation process after action {0}", ruleAction.GetType());
break;
}
}
}
result2 = true;
}
}
}
catch (InvalidRuleException exception)
{
this.context.DisableAndMarkRuleInError(rule, rule.Actions[i].ActionType, i, DeferredError.RuleError.Parsing);
this.context.RecordError(exception, ServerStrings.FolderRuleStageEvaluation);
result2 = false;
}
return(result2);
}
