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); }