public static ReplyTemplate Find(MailboxSession session, RuleAction.OOFReply ruleAction)
{
ReplyTemplate result;
try
{
if (ruleAction.ReplyTemplateMessageEntryID == null)
{
result = ReplyTemplate.FindByTemplateGuid(session, ruleAction);
}
else
{
StoreObjectId messageId = StoreObjectId.FromProviderSpecificId(ruleAction.ReplyTemplateMessageEntryID);
MessageItem messageItem = MessageItem.Bind(session, messageId, new PropertyDefinition[]
{
ItemSchema.ReplyTemplateId
});
messageItem.OpenAsReadWrite();
ReplyTemplate.Tracer.TraceDebug <IExchangePrincipal, ByteArray>(0L, "Mailbox:{0}: Found reply template by entry Id. Entry id={1}", session.MailboxOwner, new ByteArray(ruleAction.ReplyTemplateMessageEntryID));
ReplyTemplate.TracerPfd.TracePfd <int, IExchangePrincipal, ByteArray>(0L, "PFD IWO {0} Mailbox:{1}: Found reply template by entry Id. Entry id={2}", 31639, session.MailboxOwner, new ByteArray(ruleAction.ReplyTemplateMessageEntryID));
result = new ReplyTemplate(messageItem);
}
}
catch (ObjectNotFoundException)
{
ReplyTemplate.Tracer.TraceDebug <IExchangePrincipal, ByteArray>(0L, "Mailbox:{0}: Found no reply template by entry Id. Entry id={1}", session.MailboxOwner, new ByteArray(ruleAction.ReplyTemplateMessageEntryID));
result = ReplyTemplate.FindByTemplateGuid(session, ruleAction);
}
return(result);
}
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 static ReplyTemplate FindByTemplateGuid(MailboxSession session, RuleAction.OOFReply ruleAction)
{
MessageItem messageItem = null;
try
{
using (Folder folder = Folder.Bind(session, DefaultFolderType.Inbox))
{
byte[] replyTemplateEntryIdFromTemplateGuid = ReplyTemplate.GetReplyTemplateEntryIdFromTemplateGuid(folder, ruleAction.ReplyTemplateGuid);
if (replyTemplateEntryIdFromTemplateGuid != null)
{
StoreObjectId storeObjectId = StoreObjectId.FromProviderSpecificId(replyTemplateEntryIdFromTemplateGuid);
messageItem = MessageItem.Bind(session, storeObjectId, new PropertyDefinition[]
{
ItemSchema.ReplyTemplateId
});
messageItem.OpenAsReadWrite();
ReplyTemplate.Tracer.TraceDebug <IExchangePrincipal, Guid, byte[]>(0L, "Mailbox:{0}: Found reply template by GUID. GUID={1}, Entry Id={2}", session.MailboxOwner, ruleAction.ReplyTemplateGuid, storeObjectId.GetBytes());
}
else
{
ReplyTemplate.Tracer.TraceDebug <IExchangePrincipal, Guid>(0L, "Mailbox:{0}: Found no reply template by GUID. GUID={1}", session.MailboxOwner, ruleAction.ReplyTemplateGuid);
messageItem = null;
}
}
}
catch (ObjectNotFoundException)
{
return(null);
}
if (messageItem != null)
{
return(new ReplyTemplate(messageItem));
}
return(null);
}
internal static RuleAction ConvertRuleAction(StoreSession session, ExTimeZone timeZone, RuleAction ruleAction)
{
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullArgument(timeZone, "timeZone");
Util.ThrowOnNullArgument(ruleAction, "ruleAction");
switch (ruleAction.ActionType)
{
case RuleAction.Type.OP_MOVE:
{
RuleAction.MoveCopy moveCopy = (RuleAction.MoveCopy)ruleAction;
if (moveCopy.FolderIsInThisStore)
{
return(new RuleAction.MoveAction(moveCopy.UserFlags, RuleActionConverter.EntryIdToStoreObjectId(moveCopy.FolderEntryID, StoreObjectType.Folder)));
}
return(new RuleAction.MoveAction(moveCopy.UserFlags, moveCopy.StoreEntryID, moveCopy.FolderEntryID));
}
case RuleAction.Type.OP_COPY:
{
RuleAction.MoveCopy moveCopy2 = (RuleAction.MoveCopy)ruleAction;
if (moveCopy2.FolderIsInThisStore)
{
return(new RuleAction.CopyAction(moveCopy2.UserFlags, RuleActionConverter.EntryIdToStoreObjectId(moveCopy2.FolderEntryID, StoreObjectType.Folder)));
}
return(new RuleAction.CopyAction(moveCopy2.UserFlags, moveCopy2.StoreEntryID, moveCopy2.FolderEntryID));
}
case RuleAction.Type.OP_REPLY:
{
RuleAction.Reply reply = (RuleAction.Reply)ruleAction;
return(new RuleAction.ReplyAction(reply.UserFlags, RuleActionConverter.MapiReplyFlagsToReplyFlags(reply.Flags), RuleActionConverter.GetReplyTemplateStoreObjectId(reply.ReplyTemplateMessageEntryID), reply.ReplyTemplateGuid));
}
case RuleAction.Type.OP_OOF_REPLY:
{
RuleAction.OOFReply oofreply = (RuleAction.OOFReply)ruleAction;
return(new RuleAction.OutOfOfficeReplyAction(oofreply.UserFlags, RuleActionConverter.GetReplyTemplateStoreObjectId(oofreply.ReplyTemplateMessageEntryID), oofreply.ReplyTemplateGuid));
}
case RuleAction.Type.OP_DEFER_ACTION:
{
RuleAction.Defer defer = (RuleAction.Defer)ruleAction;
return(new RuleAction.DeferAction(defer.UserFlags, defer.Data));
}
case RuleAction.Type.OP_BOUNCE:
{
RuleAction.Bounce bounce = (RuleAction.Bounce)ruleAction;
return(new RuleAction.BounceAction(bounce.UserFlags, (uint)bounce.Code));
}
case RuleAction.Type.OP_FORWARD:
{
RuleAction.Forward forward = (RuleAction.Forward)ruleAction;
return(new RuleAction.ForwardAction(forward.UserFlags, RuleActionConverter.GetRecipients(session, timeZone, forward.Recipients), RuleActionConverter.MapiForwardFlagsToForwardFlags(forward.Flags)));
}
case RuleAction.Type.OP_DELEGATE:
{
RuleAction.Delegate @delegate = (RuleAction.Delegate)ruleAction;
return(new RuleAction.DelegateAction(@delegate.UserFlags, RuleActionConverter.GetRecipients(session, timeZone, @delegate.Recipients)));
}
case RuleAction.Type.OP_TAG:
{
RuleAction.Tag tag = (RuleAction.Tag)ruleAction;
NativeStorePropertyDefinition propertyDefinition = null;
try
{
propertyDefinition = PropertyTagCache.Cache.SafePropertyDefinitionsFromPropTags(session, new PropTag[]
{
tag.Value.PropTag
})[0];
}
catch (CorruptDataException)
{
if (session.IsMoveUser)
{
return(new RuleAction.TagAction(tag.UserFlags, InternalSchema.RuleError, 0));
}
throw;
}
object valueFromPropValue = MapiPropertyBag.GetValueFromPropValue(session, timeZone, propertyDefinition, tag.Value);
return(new RuleAction.TagAction(tag.UserFlags, propertyDefinition, valueFromPropValue));
}
case RuleAction.Type.OP_DELETE:
{
RuleAction.Delete delete = (RuleAction.Delete)ruleAction;
return(new RuleAction.DeleteAction(delete.UserFlags));
}
case RuleAction.Type.OP_MARK_AS_READ:
{
RuleAction.MarkAsRead markAsRead = (RuleAction.MarkAsRead)ruleAction;
return(new RuleAction.MarkAsReadAction(markAsRead.UserFlags));
}
default:
throw new ArgumentException(string.Format("Invalid action type {0}.", ruleAction.ActionType));
}
}
internal static RuleAction ConvertRuleAction(StoreSession session, ExTimeZone timeZone, RuleAction ruleAction)
{
Util.ThrowOnNullArgument(session, "session");
Util.ThrowOnNullArgument(timeZone, "timeZone");
Util.ThrowOnNullArgument(ruleAction, "ruleAction");
RuleAction ruleAction2;
switch (ruleAction.ActionType)
{
case RuleActionType.Move:
{
RuleAction.MoveAction moveAction = (RuleAction.MoveAction)ruleAction;
if (moveAction.ExternalDestinationFolderId != null)
{
ruleAction2 = new RuleAction.ExternalMove(moveAction.DestinationStoreEntryId, moveAction.ExternalDestinationFolderId);
}
else
{
ruleAction2 = new RuleAction.InMailboxMove(moveAction.DestinationFolderId.ProviderLevelItemId);
}
break;
}
case RuleActionType.Copy:
{
RuleAction.CopyAction copyAction = (RuleAction.CopyAction)ruleAction;
if (copyAction.ExternalDestinationFolderId != null)
{
ruleAction2 = new RuleAction.ExternalCopy(copyAction.DestinationStoreEntryId, copyAction.ExternalDestinationFolderId);
}
else
{
ruleAction2 = new RuleAction.InMailboxCopy(copyAction.DestinationFolderId.ProviderLevelItemId);
}
break;
}
case RuleActionType.Reply:
{
RuleAction.ReplyAction replyAction = (RuleAction.ReplyAction)ruleAction;
ruleAction2 = new RuleAction.Reply(RuleActionConverter.GetReplyTemplateMessageEntryId(replyAction.ReplyTemplateMessageId), replyAction.ReplyTemplateGuid, RuleActionConverter.ReplyFlagsToMapiReplyFlags(replyAction.Flags));
break;
}
case RuleActionType.OutOfOfficeReply:
{
RuleAction.OutOfOfficeReplyAction outOfOfficeReplyAction = (RuleAction.OutOfOfficeReplyAction)ruleAction;
ruleAction2 = new RuleAction.OOFReply(RuleActionConverter.GetReplyTemplateMessageEntryId(outOfOfficeReplyAction.ReplyTemplateMessageId), outOfOfficeReplyAction.ReplyTemplateGuid);
break;
}
case RuleActionType.DeferAction:
{
RuleAction.DeferAction deferAction = (RuleAction.DeferAction)ruleAction;
ruleAction2 = new RuleAction.Defer(deferAction.Data);
break;
}
case RuleActionType.Bounce:
{
RuleAction.BounceAction bounceAction = (RuleAction.BounceAction)ruleAction;
ruleAction2 = new RuleAction.Bounce((RuleAction.Bounce.BounceCode)bounceAction.BounceCode);
break;
}
case RuleActionType.Forward:
{
RuleAction.ForwardAction forwardAction = (RuleAction.ForwardAction)ruleAction;
ruleAction2 = new RuleAction.Forward(RuleActionConverter.GetAdrEntries(session, timeZone, forwardAction.Recipients), RuleActionConverter.ForwardFlagsToMapiForwardFlags(forwardAction.Flags));
break;
}
case RuleActionType.Delegate:
{
RuleAction.DelegateAction delegateAction = (RuleAction.DelegateAction)ruleAction;
ruleAction2 = new RuleAction.Delegate(RuleActionConverter.GetAdrEntries(session, timeZone, delegateAction.Recipients));
break;
}
case RuleActionType.Tag:
{
RuleAction.TagAction tagAction = (RuleAction.TagAction)ruleAction;
PropTag propTag = PropertyTagCache.Cache.PropTagsFromPropertyDefinitions(session.Mailbox.MapiStore, session, new NativeStorePropertyDefinition[]
{
tagAction.PropertyDefinition
}).First <PropTag>();
ruleAction2 = new RuleAction.Tag(MapiPropertyBag.GetPropValueFromValue(session, timeZone, propTag, tagAction.PropertyValue));
break;
}
case RuleActionType.Delete:
{
RuleAction.DeleteAction deleteAction = (RuleAction.DeleteAction)ruleAction;
ruleAction2 = new RuleAction.Delete();
break;
}
case RuleActionType.MarkAsRead:
{
RuleAction.MarkAsReadAction markAsReadAction = (RuleAction.MarkAsReadAction)ruleAction;
ruleAction2 = new RuleAction.MarkAsRead();
break;
}
default:
throw new ArgumentException(string.Format("Invalid action type {0}.", ruleAction.ActionType));
}
ruleAction2.UserFlags = ruleAction.UserFlags;
return(ruleAction2);
}
private void UpdateOofRule(Rule rule, ReplyBody reply, string ruleName, string messageClass, OofReplyType oofReplyType, RuleGenerator.ConditionType conditionType, int sequenceNumber, OofState mailboxOofState)
{
bool flag = false;
bool flag2 = false;
Restriction restriction = this.GetRestriction(conditionType);
RuleAction.OOFReply ruleAction = (RuleAction.OOFReply)rule.Actions[0];
ReplyTemplate replyTemplate = null;
try
{
replyTemplate = ReplyTemplate.Find(this.itemStore, ruleAction);
if (replyTemplate != null)
{
RuleGenerator.Tracer.TraceDebug <IExchangePrincipal, string>((long)this.GetHashCode(), "Mailbox:{0}: Updating ReplyTemplate to Body: '{1}'", this.itemStore.MailboxOwner, reply.RawMessage);
if (this.userOofSettings.SetByLegacyClient)
{
flag2 = !replyTemplate.PlainTextBody.Equals(reply.RawMessage, StringComparison.Ordinal);
replyTemplate.PlainTextBody = reply.RawMessage;
}
else
{
string value = TextUtil.ConvertHtmlToPlainText(reply.RawMessage);
flag2 = !replyTemplate.PlainTextBody.Equals(value, StringComparison.Ordinal);
replyTemplate.CharSet = this.GetDefaultCharsetForCountryCode(reply.LanguageTag);
replyTemplate.HtmlBody = reply.RawMessage;
}
replyTemplate.OofReplyType = oofReplyType;
replyTemplate.ClassName = messageClass;
replyTemplate.SaveChanges();
if (flag2)
{
rule.StateFlags |= RuleStateFlags.ClearOOFHistory;
byte[] propValue = this.itemStore.__ContainedMapiStore.GlobalIdFromId(rule.ID);
OofHistory.RemoveOofHistoryEntriesWithProperty(this.itemStore, mailboxOofState != OofState.Disabled, OofHistory.PropId.GlobalRuleId, propValue);
RuleGenerator.Tracer.TraceDebug <IExchangePrincipal, string>((long)this.GetHashCode(), "Mailbox:{0}: Updated reply template for global rule '{1}'", this.itemStore.MailboxOwner, ruleName);
}
}
else
{
Guid guid = Guid.NewGuid();
byte[] replyTemplateMessageEntryID = this.CreateOofReplyTemplate(this.itemStore, guid, reply, messageClass, oofReplyType);
rule.Actions = new RuleAction[]
{
new RuleAction.OOFReply(replyTemplateMessageEntryID, guid)
};
flag = true;
RuleGenerator.Tracer.TraceDebug <IExchangePrincipal, string>((long)this.GetHashCode(), "Mailbox:{0}: Created new reply template and updated global rule '{1}'", this.itemStore.MailboxOwner, ruleName);
}
RuleGenerator.TracerPfd.TracePfd <int, string, IExchangePrincipal>((long)this.GetHashCode(), "PFD IWO {0} Updated OOF Rule '{1}' for Mailbox:{2}", 25495, ruleName, this.itemStore.MailboxOwner);
}
finally
{
if (replyTemplate != null)
{
replyTemplate.Dispose();
}
}
if (!ConditionComparer.Equals(rule.Condition, restriction))
{
rule.Condition = restriction;
flag = true;
RuleGenerator.Tracer.TraceDebug <IExchangePrincipal, string>((long)this.GetHashCode(), "Mailbox:{0}: Updated rule '{1}' with new condition", this.itemStore.MailboxOwner, ruleName);
}
if (flag || flag2)
{
this.ruleManager.Update(rule);
}
}
public RuleActionOOFReplyData(RuleAction.OOFReply ruleAction) : base(ruleAction, ruleAction.ReplyTemplateMessageEntryID, ruleAction.ReplyTemplateGuid, 0U)
{
}
public void WriteAction(RuleAction action)
{
this.CheckDisposed(null);
this.writer.WriteStartElement("Action");
if (action == null)
{
this.writer.WriteAttributeString("Type", ServerStrings.Null);
}
else
{
this.writer.WriteAttributeString("Type", action.ActionType.ToString());
this.writer.WriteAttributeString("UserFlags", action.UserFlags.ToString("X08"));
switch (action.ActionType)
{
case RuleAction.Type.OP_MOVE:
case RuleAction.Type.OP_COPY:
this.WriteMoveCopyAction((RuleAction.MoveCopy)action);
break;
case RuleAction.Type.OP_REPLY:
{
RuleAction.Reply reply = (RuleAction.Reply)action;
this.writer.WriteAttributeString("ActionFlags", reply.Flags.ToString());
byte[] replyTemplateMessageEntryID = reply.ReplyTemplateMessageEntryID;
Guid replyTemplateGuid = reply.ReplyTemplateGuid;
this.WriteReplyAction(replyTemplateMessageEntryID, replyTemplateGuid, true);
break;
}
case RuleAction.Type.OP_OOF_REPLY:
{
RuleAction.OOFReply oofreply = (RuleAction.OOFReply)action;
byte[] replyTemplateMessageEntryID = oofreply.ReplyTemplateMessageEntryID;
Guid replyTemplateGuid = oofreply.ReplyTemplateGuid;
this.WriteReplyAction(replyTemplateMessageEntryID, replyTemplateGuid, false);
break;
}
case RuleAction.Type.OP_DEFER_ACTION:
{
RuleAction.Defer defer = (RuleAction.Defer)action;
this.WriteBinaryData("Defer", defer.Data);
break;
}
case RuleAction.Type.OP_BOUNCE:
{
RuleAction.Bounce bounce = (RuleAction.Bounce)action;
this.writer.WriteAttributeString("BounceCode", bounce.Code.ToString());
break;
}
case RuleAction.Type.OP_FORWARD:
{
RuleAction.Forward forward = (RuleAction.Forward)action;
this.writer.WriteAttributeString("ForwardFlags", forward.Flags.ToString());
this.WriteForwardRecipients(forward.Recipients);
break;
}
case RuleAction.Type.OP_DELEGATE:
{
RuleAction.Delegate @delegate = (RuleAction.Delegate)action;
this.WriteForwardRecipients(@delegate.Recipients);
break;
}
case RuleAction.Type.OP_TAG:
{
RuleAction.Tag tag = (RuleAction.Tag)action;
this.WritePropValue(tag.Value);
break;
}
}
}
this.writer.WriteEndElement();
}
