public static void ProcessContentFilter(string contentFilter, int contentFilterLCID, PSCmdlet cmdlet, IFilterBuilderHelper mapper, out RestrictionData restriction, out string normalizedFilter)
{
Exception ex = null;
try
{
QueryParser queryParser = new QueryParser(contentFilter, ObjectSchema.GetInstance <ContentFilterSchema>(), QueryParser.Capabilities.All, (cmdlet != null) ? new QueryParser.EvaluateVariableDelegate(cmdlet.GetVariableValue) : null, new QueryParser.ConvertValueFromStringDelegate(ContentFilterBuilder.ConvertValueFromString));
QueryFilter parseTree = queryParser.ParseTree;
Restriction restriction2 = ContentFilterBuilder.BuildRestriction(parseTree, mapper);
restriction = RestrictionData.GetRestrictionData(restriction2);
restriction.LCID = contentFilterLCID;
normalizedFilter = parseTree.GenerateInfixString(FilterLanguage.Monad);
return;
}
catch (InvalidCastException ex2)
{
ex = ex2;
}
catch (ParsingException ex3)
{
ex = ex3;
}
catch (ArgumentOutOfRangeException ex4)
{
ex = ex4;
}
throw new InvalidContentFilterPermanentException(ex.Message, ex);
}
private static Restriction BuildBasicRestriction(QueryFilter filter, PropTag ptagToSearch, object propValue)
{
TextFilter textFilter = filter as TextFilter;
if (textFilter != null)
{
return(ContentFilterBuilder.BuildTextRestriction(textFilter, ptagToSearch, propValue));
}
ComparisonFilter comparisonFilter = filter as ComparisonFilter;
if (comparisonFilter != null)
{
return(ContentFilterBuilder.BuildComparisonRestriction(comparisonFilter, ptagToSearch, propValue));
}
return(null);
}
internal static Restriction BuildAttachmentRestriction(SinglePropertyFilter filter, IFilterBuilderHelper mapper)
{
Restriction restriction = ContentFilterBuilder.BuildRestrictionWrapper(filter, PropTag.SearchAttachments, mapper, new ContentFilterBuilder.BuildRestrictionDelegate(ContentFilterBuilder.BuildPropertyRestrictionInternal));
Restriction restriction2 = Restriction.Or(new Restriction[]
{
ContentFilterBuilder.BuildRestrictionWrapper(filter, PropTag.AttachFileName, mapper, new ContentFilterBuilder.BuildRestrictionDelegate(ContentFilterBuilder.BuildPropertyRestrictionInternal)),
ContentFilterBuilder.BuildRestrictionWrapper(filter, PropTag.AttachLongFileName, mapper, new ContentFilterBuilder.BuildRestrictionDelegate(ContentFilterBuilder.BuildPropertyRestrictionInternal)),
ContentFilterBuilder.BuildRestrictionWrapper(filter, PropTag.AttachExtension, mapper, new ContentFilterBuilder.BuildRestrictionDelegate(ContentFilterBuilder.BuildPropertyRestrictionInternal)),
ContentFilterBuilder.BuildRestrictionWrapper(filter, PropTag.DisplayName, mapper, new ContentFilterBuilder.BuildRestrictionDelegate(ContentFilterBuilder.BuildPropertyRestrictionInternal))
});
return(Restriction.Or(new Restriction[]
{
restriction,
Restriction.Sub(PropTag.MessageAttachments, restriction2)
}));
}
internal static Restriction BuildIsReadRestriction(SinglePropertyFilter filter, IFilterBuilderHelper mapper)
{
ContentFilterSchema.ContentFilterPropertyDefinition contentFilterPropertyDefinition = (ContentFilterSchema.ContentFilterPropertyDefinition)filter.Property;
PropTag propTagToSearch = contentFilterPropertyDefinition.PropTagToSearch;
bool flag;
ContentFilterBuilder.CheckFilterIsEQorNE(filter, out flag);
bool flag2 = (bool)ContentFilterBuilder.GetPropertyValue(filter);
if (flag)
{
flag2 = !flag2;
}
if (!flag2)
{
return(Restriction.BitMaskZero(propTagToSearch, 1));
}
return(Restriction.BitMaskNonZero(propTagToSearch, 1));
}
private static Restriction BuildRestriction(QueryFilter filter, IFilterBuilderHelper helper)
{
CompositeFilter compositeFilter = filter as CompositeFilter;
if (compositeFilter != null)
{
Restriction[] array = new Restriction[compositeFilter.FilterCount];
int num = 0;
foreach (QueryFilter filter2 in compositeFilter.Filters)
{
array[num++] = ContentFilterBuilder.BuildRestriction(filter2, helper);
}
if (compositeFilter is AndFilter)
{
return(Restriction.And(array));
}
if (compositeFilter is OrFilter)
{
return(Restriction.Or(array));
}
throw ContentFilterBuilder.UnexpectedFilterType(filter);
}
else
{
NotFilter notFilter = filter as NotFilter;
if (notFilter != null)
{
return(Restriction.Not(ContentFilterBuilder.BuildRestriction(notFilter.Filter, helper)));
}
SinglePropertyFilter singlePropertyFilter = filter as SinglePropertyFilter;
if (singlePropertyFilter == null)
{
throw ContentFilterBuilder.UnexpectedFilterType(filter);
}
ContentFilterSchema.ContentFilterPropertyDefinition contentFilterPropertyDefinition = singlePropertyFilter.Property as ContentFilterSchema.ContentFilterPropertyDefinition;
if (contentFilterPropertyDefinition == null)
{
throw ContentFilterBuilder.UnexpectedFilterType(filter);
}
return(contentFilterPropertyDefinition.ConvertToRestriction(singlePropertyFilter, helper));
}
}
private static Restriction BuildRecipientRestrictionInternal(SinglePropertyFilter filter, IFilterBuilderHelper mapper, PropTag ptagToSearch)
{
List <Restriction> list = new List <Restriction>();
bool flag;
ContentFilterBuilder.CheckFilterIsEQorNE(filter, out flag);
object propertyValue = ContentFilterBuilder.GetPropertyValue(filter);
list.Add(Restriction.Content(ptagToSearch, propertyValue, ContentFlags.Prefix | ContentFlags.IgnoreCase));
string text = propertyValue as string;
if (text != null)
{
string[] array = mapper.MapRecipient(text);
if (array != null)
{
foreach (string text2 in array)
{
if (!StringComparer.OrdinalIgnoreCase.Equals(text2, text))
{
list.Add(Restriction.Content(ptagToSearch, text2, ContentFlags.Prefix | ContentFlags.IgnoreCase));
}
}
}
}
Restriction restriction;
if (list.Count == 1)
{
restriction = list[0];
}
else
{
restriction = Restriction.Or(list.ToArray());
}
if (!flag)
{
return(restriction);
}
return(Restriction.Not(restriction));
}
internal static Restriction BuildIsFlaggedRestriction(SinglePropertyFilter filter, IFilterBuilderHelper mapper)
{
ContentFilterSchema.ContentFilterPropertyDefinition contentFilterPropertyDefinition = (ContentFilterSchema.ContentFilterPropertyDefinition)filter.Property;
PropTag propTagToSearch = contentFilterPropertyDefinition.PropTagToSearch;
bool flag;
ContentFilterBuilder.CheckFilterIsEQorNE(filter, out flag);
bool flag2 = (bool)ContentFilterBuilder.GetPropertyValue(filter);
if (flag)
{
flag2 = !flag2;
}
Restriction restriction = Restriction.EQ(propTagToSearch, 2);
if (!flag2)
{
return(Restriction.Not(restriction));
}
return(restriction);
}
private static Restriction BuildComparisonRestriction(ComparisonFilter filter, PropTag ptagToSearch, object propValue)
{
Restriction.PropertyRestriction propertyRestriction;
switch (filter.ComparisonOperator)
{
case ComparisonOperator.Equal:
propertyRestriction = (Restriction.PropertyRestriction)Restriction.EQ(ptagToSearch, propValue);
break;
case ComparisonOperator.NotEqual:
propertyRestriction = (Restriction.PropertyRestriction)Restriction.NE(ptagToSearch, propValue);
break;
case ComparisonOperator.LessThan:
propertyRestriction = (Restriction.PropertyRestriction)Restriction.LT(ptagToSearch, propValue);
break;
case ComparisonOperator.LessThanOrEqual:
propertyRestriction = (Restriction.PropertyRestriction)Restriction.LE(ptagToSearch, propValue);
break;
case ComparisonOperator.GreaterThan:
propertyRestriction = (Restriction.PropertyRestriction)Restriction.GT(ptagToSearch, propValue);
break;
case ComparisonOperator.GreaterThanOrEqual:
propertyRestriction = (Restriction.PropertyRestriction)Restriction.GE(ptagToSearch, propValue);
break;
default:
throw ContentFilterBuilder.UnexpectedFilterType(filter);
}
if (ptagToSearch.IsMultiValued())
{
propertyRestriction.MultiValued = true;
}
return(propertyRestriction);
}
private static Restriction BuildPolicyTagRestrictionInternal(SinglePropertyFilter filter, IFilterBuilderHelper mapper, PropTag ptagToSearch)
{
bool flag;
ContentFilterBuilder.CheckFilterIsEQorNE(filter, out flag);
List <Restriction> list = new List <Restriction>();
string text = (string)ContentFilterBuilder.GetPropertyValue(filter);
if (ContentFilterBuilder.guidRegex.Match(text).Success)
{
try
{
Guid guid = new Guid(text);
list.Add(Restriction.EQ(ptagToSearch, guid.ToByteArray()));
}
catch (FormatException)
{
}
}
if (list.Count == 0)
{
Guid[] array = mapper.MapPolicyTag(text);
if (array != null)
{
foreach (Guid guid2 in array)
{
list.Add(Restriction.EQ(ptagToSearch, guid2.ToByteArray()));
}
}
}
Restriction restriction = (list.Count == 1) ? list[0] : Restriction.Or(list.ToArray());
if (!flag)
{
return(restriction);
}
return(Restriction.Not(restriction));
}
private static object GetPropertyValue(QueryFilter filter)
{
TextFilter textFilter = filter as TextFilter;
if (textFilter != null)
{
return(textFilter.Text);
}
ComparisonFilter comparisonFilter = filter as ComparisonFilter;
if (comparisonFilter == null)
{
throw ContentFilterBuilder.UnexpectedFilterType(filter);
}
object obj = comparisonFilter.PropertyValue;
if (obj == null)
{
return(null);
}
if (obj is DateTime)
{
obj = ((DateTime)obj).ToUniversalTime();
}
else if (obj is ByteQuantifiedSize)
{
obj = (int)((ulong)((ByteQuantifiedSize)obj));
}
else if (obj is CultureInfo)
{
obj = ((CultureInfo)obj).LCID;
}
else if (obj.GetType().IsEnum)
{
obj = (int)obj;
}
return(obj);
}
internal static Restriction BuildPolicyTagRestriction(SinglePropertyFilter filter, IFilterBuilderHelper mapper)
{
return(ContentFilterBuilder.BuildRestrictionWrapper(filter, PropTag.PolicyTag, mapper, new ContentFilterBuilder.BuildRestrictionDelegate(ContentFilterBuilder.BuildPolicyTagRestrictionInternal)));
}
internal static Restriction BuildMessageKindRestriction(SinglePropertyFilter filter, IFilterBuilderHelper mapper)
{
return(ContentFilterBuilder.BuildRestrictionWrapper(filter, PropTag.MessageClass, mapper, new ContentFilterBuilder.BuildRestrictionDelegate(ContentFilterBuilder.BuildMessageKindRestrictionInternal)));
}
private static Restriction BuildMessageKindRestrictionInternal(SinglePropertyFilter filter, IFilterBuilderHelper mapper, PropTag ptagToSearch)
{
List <string> list = new List <string>();
bool flag;
ContentFilterBuilder.CheckFilterIsEQorNE(filter, out flag);
switch ((MessageKindEnum)ContentFilterBuilder.GetPropertyValue(filter))
{
case MessageKindEnum.Email:
list.Add("IPM.Note");
break;
case MessageKindEnum.Calendar:
list.Add("IPM.Schedule");
list.Add("IPM.Appointment");
break;
case MessageKindEnum.Task:
list.Add("IPM.Task");
break;
case MessageKindEnum.Note:
list.Add("IPM.StickyNote");
break;
case MessageKindEnum.Doc:
list.Add("IPM.Document");
break;
case MessageKindEnum.Journal:
list.Add("IPM.Activity");
break;
case MessageKindEnum.Contact:
list.Add("IPM.Contact");
break;
case MessageKindEnum.InstantMessage:
list.Add("IPM.Note.Microsoft.Conversation");
list.Add("IPM.Note.Microsoft.Missed");
list.Add("IPM.Note.Microsoft.Conversation.Voice");
list.Add("IPM.Note.Microsoft.Missed.Voice");
break;
case MessageKindEnum.Voicemail:
list.Add("IPM.Note.Microsoft.Voicemail");
break;
case MessageKindEnum.Fax:
list.Add("IPM.Note.Microsoft.Fax");
break;
case MessageKindEnum.Post:
list.Add("IPM.Post");
break;
case MessageKindEnum.RSSFeed:
list.Add("IPM.Post.RSS");
break;
default:
throw ContentFilterBuilder.UnexpectedFilterType(filter);
}
Restriction[] array = new Restriction[list.Count];
for (int i = 0; i < list.Count; i++)
{
array[i] = Restriction.EQ(ptagToSearch, list[i]);
}
Restriction restriction = (array.Length == 1) ? array[0] : Restriction.Or(array);
if (!flag)
{
return(restriction);
}
return(Restriction.Not(restriction));
}
private static Restriction BuildPropertyRestrictionInternal(SinglePropertyFilter filter, IFilterBuilderHelper mapper, PropTag ptagToSearch)
{
return(ContentFilterBuilder.BuildBasicRestriction(filter, ptagToSearch, ContentFilterBuilder.GetPropertyValue(filter)));
}
protected override void MakeConnections()
{
Exception sourceConnectFailure = null;
Exception targetConnectFailure = null;
int sourceVersion = 0;
int targetVersion = 0;
string sourceServerName = null;
string targetServerName = null;
CommonUtils.CatchKnownExceptions(delegate
{
MrsTracer.Service.Debug("Attempting to connect to the destination mailbox {0}.", new object[]
{
this.MailboxMerger.TargetTracingID
});
this.MailboxMerger.ConnectDestinationMailbox(MailboxConnectFlags.None);
}, delegate(Exception failure)
{
MrsTracer.Service.Warning("Failed to connect to destination mailbox: {0}", new object[]
{
CommonUtils.FullExceptionMessage(failure)
});
targetConnectFailure = failure;
});
if (targetConnectFailure == null)
{
MailboxServerInformation mailboxServerInformation = this.MailboxMerger.DestMailbox.GetMailboxServerInformation();
MailboxInformation mailboxInformation = this.MailboxMerger.DestMailbox.GetMailboxInformation();
this.MailboxMerger.TargetServerInfo = mailboxServerInformation;
if (mailboxServerInformation != null)
{
ConnectivityRec connectivityRec = new ConnectivityRec(ServerKind.Target, mailboxInformation, mailboxServerInformation);
base.Report.Append(MrsStrings.ReportDestinationMailboxConnection(this.MailboxMerger.TargetTracingID, mailboxServerInformation.ServerInfoString, (mailboxInformation != null) ? mailboxInformation.MdbName : "(null)"), connectivityRec);
targetServerName = mailboxServerInformation.MailboxServerName;
targetVersion = mailboxServerInformation.MailboxServerVersion;
}
if (!this.MailboxMerger.DestMailbox.MailboxExists())
{
throw new MailboxDoesNotExistPermanentException(this.MailboxMerger.TargetTracingID);
}
MrsTracer.Service.Debug("Destination mailbox {0} exists.", new object[]
{
this.MailboxMerger.TargetTracingID
});
base.TimeTracker.SetTimestamp(RequestJobTimestamp.LastSuccessfulTargetConnection, new DateTime?(DateTime.UtcNow));
base.TimeTracker.SetTimestamp(RequestJobTimestamp.TargetConnectionFailure, null);
this.MailboxMerger.LoadSyncState(base.Report);
}
if (targetConnectFailure == null)
{
this.AfterTargetConnect();
}
CommonUtils.CatchKnownExceptions(delegate
{
MrsTracer.Service.Debug("Connecting to the source mailbox {0}.", new object[]
{
this.MailboxMerger.SourceTracingID
});
this.MailboxMerger.ConnectSourceMailbox(MailboxConnectFlags.None);
}, delegate(Exception failure)
{
MrsTracer.Service.Warning("Failed to connect to source mailbox: {0}", new object[]
{
CommonUtils.FullExceptionMessage(failure)
});
sourceConnectFailure = failure;
});
if (sourceConnectFailure == null)
{
base.TimeTracker.SetTimestamp(RequestJobTimestamp.LastSuccessfulSourceConnection, new DateTime?(DateTime.UtcNow));
base.TimeTracker.SetTimestamp(RequestJobTimestamp.SourceConnectionFailure, null);
MailboxServerInformation mailboxServerInformation2 = this.MailboxMerger.SourceMailbox.GetMailboxServerInformation();
MailboxInformation mailboxInformation2 = this.MailboxMerger.SourceMailbox.GetMailboxInformation();
this.MailboxMerger.SourceServerInfo = mailboxServerInformation2;
if (mailboxServerInformation2 != null)
{
ConnectivityRec connectivityRec2 = new ConnectivityRec(ServerKind.Source, mailboxInformation2, mailboxServerInformation2);
base.Report.Append(MrsStrings.ReportSourceMailboxConnection(this.MailboxMerger.SourceTracingID, mailboxServerInformation2.ServerInfoString, (mailboxInformation2 != null) ? mailboxInformation2.MdbName : "(null)"), connectivityRec2);
sourceServerName = mailboxServerInformation2.MailboxServerName;
sourceVersion = mailboxServerInformation2.MailboxServerVersion;
}
}
if (sourceConnectFailure != null || targetConnectFailure != null)
{
base.CheckRequestIsValid();
if (sourceConnectFailure != null)
{
throw sourceConnectFailure;
}
if (targetConnectFailure != null)
{
throw targetConnectFailure;
}
}
base.SaveRequest(true, delegate(TransactionalRequestJob rj)
{
this.TimeTracker.SetTimestamp(RequestJobTimestamp.Failure, null);
this.TimeTracker.SetTimestamp(RequestJobTimestamp.Suspended, null);
rj.FailureCode = null;
rj.FailureType = null;
rj.FailureSide = null;
rj.Message = LocalizedString.Empty;
rj.SourceServer = sourceServerName;
rj.SourceVersion = sourceVersion;
rj.TargetServer = targetServerName;
rj.TargetVersion = targetVersion;
rj.Status = RequestStatus.InProgress;
this.TimeTracker.CurrentState = RequestState.InitialSeeding;
RequestJobLog.Write(rj);
});
if (!string.IsNullOrEmpty(base.CachedRequestJob.ContentFilter))
{
RestrictionData contentRestriction;
string text;
ContentFilterBuilder.ProcessContentFilter(base.CachedRequestJob.ContentFilter, base.CachedRequestJob.ContentFilterLCID, null, this.MailboxMerger.SourceMailboxWrapper, out contentRestriction, out text);
this.MailboxMerger.ContentRestriction = contentRestriction;
}
if (this.MailboxMerger.SupportsRuleAPIs)
{
this.MailboxMerger.SourceMailbox.ConfigMailboxOptions(MailboxOptions.IgnoreExtendedRuleFAIs);
}
this.MailboxMerger.ExchangeSourceAndTargetVersions();
base.ScheduleWorkItem(new Action(this.StartMerge), WorkloadType.Unknown);
}
