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));
}
}
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);
}
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)));
}
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)
}));
}
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 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 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));
}
private static Restriction BuildPropertyRestrictionInternal(SinglePropertyFilter filter, IFilterBuilderHelper mapper, PropTag ptagToSearch)
{
return(ContentFilterBuilder.BuildBasicRestriction(filter, ptagToSearch, ContentFilterBuilder.GetPropertyValue(filter)));
}
private static Restriction BuildRestrictionWrapper(SinglePropertyFilter filter, PropTag ptagToSearch, IFilterBuilderHelper mapper, ContentFilterBuilder.BuildRestrictionDelegate restrictionBuilder)
{
ContentFilterSchema.ContentFilterPropertyDefinition contentFilterPropertyDefinition = (ContentFilterSchema.ContentFilterPropertyDefinition)filter.Property;
if (ptagToSearch == PropTag.Null)
{
if (contentFilterPropertyDefinition.NamedPropToSearch != null)
{
ptagToSearch = mapper.MapNamedProperty(contentFilterPropertyDefinition.NamedPropToSearch, contentFilterPropertyDefinition.NamedPropType);
}
else
{
ptagToSearch = contentFilterPropertyDefinition.PropTagToSearch;
}
}
if (filter is ExistsFilter)
{
return(Restriction.Exist(ptagToSearch));
}
return(restrictionBuilder(filter, mapper, ptagToSearch));
}
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);
}
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));
}
