private void CreateWorkItemForReply(FolderEvaluationResult result, RuleAction.Reply action, int actionIndex)
{
if (RuleUtil.IsSameUser(this.context, this.context.RecipientCache, this.context.Sender, this.context.Recipient))
{
this.context.TraceDebug("Do not generate reply to self.");
return;
}
if (ObjectClass.IsDsn(this.context.Message.ClassName) || ObjectClass.IsMdn(this.context.Message.ClassName))
{
this.context.TraceDebug("Do not generate reply for Dsn or Mdn messages");
return;
}
if ((this.context.Message.AutoResponseSuppress & AutoResponseSuppress.AutoReply) != AutoResponseSuppress.None)
{
this.context.TraceDebug("Do not generate reply since Auto-Reply is being suppressed on current message");
return;
}
if (ObjectClass.IsApprovalMessage(this.context.Message.ClassName))
{
this.context.TraceDebug("Do not generate reply to approval message.");
return;
}
if (this.context.LimitChecker.DoesExceedAutoReplyLimit())
{
return;
}
result.AddWorkItem(new ReplyWorkItem(this.context, action.ReplyTemplateMessageEntryID, action.ReplyTemplateGuid, action.Flags, actionIndex));
}
private void CreateWorkItemForDelete(FolderEvaluationResult result, RuleAction.Delete action, int actionIndex)
{
result.ExitExecution = true;
if (result.HasDeferredMoveOrCopy)
{
this.context.TraceDebug("Softly delete the message since it is moved/copied to external store");
this.CreateWorkItemForDefer(result, action, actionIndex);
result.TargetFolder = this.context.GetDeletedItemsFolder();
return;
}
this.context.TraceDebug("Delete the message");
result.TargetFolder = null;
if (result.IsMessageDelegated)
{
this.context.TraceDebug("Message was delegated. No need to generate NRN.");
return;
}
if (!this.context.Message.IsReadReceiptRequested)
{
this.context.TraceDebug("Read Receipt is not requested on the message.");
return;
}
if (null == this.context.Message.Sender && null == this.context.Message.From && null == this.context.Message.ReadReceiptAddressee)
{
this.context.TraceDebug("No NRN recipient data, generation skipped.");
return;
}
if (this.context.IsInternetMdnDisabled)
{
this.context.TraceDebug("MDNs are disabled on the mailbox, message deleted without NRN to sender.");
return;
}
result.AddWorkItem(new DeleteWorkItem(this.context, actionIndex));
}
private void CreateWorkItemForDelegate(FolderEvaluationResult result, RuleAction.Delegate action, int actionIndex)
{
if (RuleUtil.IsNullOrEmpty(action.Recipients))
{
this.context.TraceError("Delegate recipient list is empty");
return;
}
result.AddWorkItem(new DelegateWorkItem(this.context, action.Recipients, actionIndex));
}
private void CreateWorkItemForOofReply(FolderEvaluationResult result, RuleAction.OOFReply action, int actionIndex)
{
string className = this.context.Message.ClassName;
if (ObjectClass.IsDsn(className) || ObjectClass.IsMdn(className))
{
this.context.TraceDebug("Do not generate OOF reply for Dsn or Mdn messages");
return;
}
if ((this.context.Message.AutoResponseSuppress & AutoResponseSuppress.OOF) != AutoResponseSuppress.None)
{
this.context.TraceDebug("Do not generate OOF reply when Oof Reply is being suppressed");
return;
}
if (ObjectClass.IsOfClass(className, "IPM.Note.Rules.ExternalOofTemplate.Microsoft") || ObjectClass.IsOfClass(className, "IPM.Note.Rules.OofTemplate.Microsoft"))
{
this.context.TraceDebug("Do not generate OOF reply for Oof Message");
return;
}
if (ObjectClass.IsOutlookRecall(className) || ObjectClass.IsOfClass(className, "IPM.Recall.Report.Failure") || ObjectClass.IsOfClass(className, "IPM.Recall.Report.Success"))
{
this.context.TraceDebug("Do not generate OOF reply for outlook recall Message");
return;
}
if (null == this.context.Message.Sender)
{
this.context.TraceDebug("Do not generate OOF reply for an unknown sender");
return;
}
string routingType = this.context.Message.Sender.RoutingType;
if (string.IsNullOrEmpty(routingType) || (!(routingType == "SMTP") && !(routingType == "EX") && !routingType.Equals("X400")))
{
this.context.TraceDebug <string>("Do not generate OOF reply for address type {0}", routingType ?? "<null>");
return;
}
if (RuleUtil.IsNullOrEmpty(action.ReplyTemplateMessageEntryID))
{
this.context.TraceError("Replay template message id is empty");
return;
}
bool?valueAsNullable = this.context.Message.GetValueAsNullable <bool>(ItemSchema.DelegatedByRule);
if (valueAsNullable != null && valueAsNullable.Value)
{
this.context.TraceDebug("Do not generate OOF reply for messages delegated by rule.");
return;
}
result.AddWorkItem(new OofReplyWorkItem(this.context, action.ReplyTemplateMessageEntryID, actionIndex));
}
private DeferredActionWorkItem CreateWorkItemForDefer(FolderEvaluationResult result, RuleAction action, int actionIndex)
{
string provider = this.context.CurrentRule.Provider;
DeferredActionWorkItem deferredActionWorkItem = result.GetDeferredActionWorkItem(provider);
if (deferredActionWorkItem == null)
{
this.context.TraceDebug <string>("Create Deferred Action Message for provider {0}", provider);
deferredActionWorkItem = new DeferredActionWorkItem(this.context, this.context.CurrentRule.Provider, actionIndex);
result.AddWorkItem(deferredActionWorkItem);
}
deferredActionWorkItem.AddAction(action);
return(deferredActionWorkItem);
}
private void CreateWorkItemForInMailboxCopy(FolderEvaluationResult result, RuleAction.InMailboxCopy action, int actionIndex)
{
Folder folder;
if (!this.context.TryOpenLocalStore(action.FolderEntryID, out folder))
{
this.context.TraceError <byte[]>("Could not bind to local folder {0}", action.FolderEntryID);
this.context.MarkRuleInError(this.context.CurrentRule, action.ActionType, actionIndex, DeferredError.RuleError.NoFolder);
return;
}
this.context.TraceDebug <string>("Copy to local folder {0}", folder.DisplayName);
if (!result.HasCopyWorkItemTo(folder.Id))
{
result.AddWorkItem(new CopyWorkItem(this.context, folder, actionIndex));
return;
}
this.context.TraceDebug("Duplicate copy to a folder will be ignored");
}
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));
}
private void CreateWorkItemForTag(FolderEvaluationResult result, RuleAction.Tag action, int actionIndex)
{
result.AddWorkItem(new TagWorkItem(this.context, action.Value, actionIndex));
}
private void CreateWorkItemForMarkAsRead(FolderEvaluationResult result, RuleAction.MarkAsRead action, int actionIndex)
{
result.AddWorkItem(new MarkAsReadWorkItem(this.context, actionIndex));
}
