public QueryFilterBuilder(CultureInfo culture, AqsParser.ParseOption options)
{
this.culture = culture;
this.options = options;
this.AllowedKeywords = PropertyKeywordHelper.AllPropertyKeywords;
this.filterBuilderMap = new Dictionary <PropertyKeyword, QueryFilterBuilder.FilterBuildDelegate>();
this.filterBuilderMap.Add(PropertyKeyword.From, new QueryFilterBuilder.FilterBuildDelegate(this.BuildFromFilter));
this.filterBuilderMap.Add(PropertyKeyword.To, new QueryFilterBuilder.FilterBuildDelegate(this.BuildToFilter));
this.filterBuilderMap.Add(PropertyKeyword.Bcc, new QueryFilterBuilder.FilterBuildDelegate(this.BuildBccFilter));
this.filterBuilderMap.Add(PropertyKeyword.Cc, new QueryFilterBuilder.FilterBuildDelegate(this.BuildCcFilter));
this.filterBuilderMap.Add(PropertyKeyword.Participants, new QueryFilterBuilder.FilterBuildDelegate(this.BuildParticipantsFilter));
this.filterBuilderMap.Add(PropertyKeyword.Subject, new QueryFilterBuilder.FilterBuildDelegate(this.BuildSubjectFilter));
this.filterBuilderMap.Add(PropertyKeyword.Body, new QueryFilterBuilder.FilterBuildDelegate(this.BuildBodyFilter));
this.filterBuilderMap.Add(PropertyKeyword.Sent, new QueryFilterBuilder.FilterBuildDelegate(this.BuildSentFilter));
this.filterBuilderMap.Add(PropertyKeyword.Received, new QueryFilterBuilder.FilterBuildDelegate(this.BuildReceivedFilter));
this.filterBuilderMap.Add(PropertyKeyword.Attachment, new QueryFilterBuilder.FilterBuildDelegate(this.BuildAttachmentFilter));
this.filterBuilderMap.Add(PropertyKeyword.AttachmentNames, new QueryFilterBuilder.FilterBuildDelegate(this.BuildAttachmentNamesFilter));
this.filterBuilderMap.Add(PropertyKeyword.Kind, new QueryFilterBuilder.FilterBuildDelegate(this.BuildKindFilter));
this.filterBuilderMap.Add(PropertyKeyword.PolicyTag, new QueryFilterBuilder.FilterBuildDelegate(this.BuildPolicyTagFilter));
this.filterBuilderMap.Add(PropertyKeyword.Expires, new QueryFilterBuilder.FilterBuildDelegate(this.BuildExpiresFilter));
this.filterBuilderMap.Add(PropertyKeyword.IsFlagged, new QueryFilterBuilder.FilterBuildDelegate(this.BuildIsFlaggedFilter));
this.filterBuilderMap.Add(PropertyKeyword.IsRead, new QueryFilterBuilder.FilterBuildDelegate(this.BuildIsReadFilter));
this.filterBuilderMap.Add(PropertyKeyword.Category, new QueryFilterBuilder.FilterBuildDelegate(this.BuildCategoryFilter));
this.filterBuilderMap.Add(PropertyKeyword.Importance, new QueryFilterBuilder.FilterBuildDelegate(this.BuildImportanceFilter));
this.filterBuilderMap.Add(PropertyKeyword.Size, new QueryFilterBuilder.FilterBuildDelegate(this.BuildSizeFilter));
this.filterBuilderMap.Add(PropertyKeyword.HasAttachment, new QueryFilterBuilder.FilterBuildDelegate(this.BuildHasAttachmentFilter));
this.filterBuilderMap.Add(PropertyKeyword.All, new QueryFilterBuilder.FilterBuildDelegate(this.BuildAllFilter));
}
public static QueryFilter ParseAndBuildQuery(string query, AqsParser.ParseOption parseOption, CultureInfo culture, RescopedAll rescopedAll, IRecipientResolver recipientResolver, IPolicyTagProvider policyTagProvider)
{
AqsParser aqsParser = new AqsParser();
QueryFilter queryFilter = null;
using (Condition condition = aqsParser.Parse(query, parseOption, culture))
{
QueryFilterBuilder queryFilterBuilder = new QueryFilterBuilder(culture, parseOption);
queryFilterBuilder.RescopedAll = rescopedAll;
queryFilterBuilder.RecipientResolver = recipientResolver;
queryFilterBuilder.PolicyTagProvider = policyTagProvider;
queryFilterBuilder.AllowedKeywords = aqsParser.AllowedKeywords;
if (condition != null)
{
queryFilter = queryFilterBuilder.Build(condition);
}
if (queryFilter == null)
{
if (!aqsParser.SuppressError)
{
throw new ParserException(new ParserErrorInfo(ParserErrorCode.ParserError));
}
queryFilter = queryFilterBuilder.BuildAllFilter(1, query);
}
}
return(queryFilter);
}
public SearchWorkDefinition ParseSearch(ComplianceMessage target, SearchWorkDefinition definition)
{
QueryFilter queryFilter = null;
string query = definition.Query;
CultureInfo culture;
FaultDefinition faultDefinition;
ExceptionHandler.Parser.TryRun(delegate
{
if (string.IsNullOrEmpty(target.Culture))
{
culture = CultureInfo.InvariantCulture;
}
else
{
culture = CultureInfo.GetCultureInfo(target.Culture);
}
Func <IRecipientResolver, IPolicyTagProvider, QueryFilter> func = null;
switch (definition.Parser)
{
case SearchWorkDefinition.QueryParser.KQL:
func = ((IRecipientResolver r, IPolicyTagProvider p) => KqlParser.ParseAndBuildQuery(query, KqlParser.ParseOption.EDiscoveryMode, culture, r, p));
break;
case SearchWorkDefinition.QueryParser.AQS:
func = delegate(IRecipientResolver r, IPolicyTagProvider p)
{
AqsParser.ParseOption parseOption = AqsParser.ParseOption.UseCiKeywordOnly | AqsParser.ParseOption.DisablePrefixMatch | AqsParser.ParseOption.AllowShortWildcards;
return(AqsParser.ParseAndBuildQuery(query, parseOption, culture, r, p));
};
break;
}
if (func != null)
{
OrganizationId scopingOrganizationId = null;
IPolicyTagProvider arg = null;
IRecipientResolver arg2 = null;
if (OrganizationId.TryCreateFromBytes(target.TenantId, Encoding.UTF8, out scopingOrganizationId))
{
ADSessionSettings adsessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(scopingOrganizationId);
adsessionSettings.IncludeInactiveMailbox = true;
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.PartiallyConsistent, adsessionSettings, 146, "ParseSearch", "f:\\15.00.1497\\sources\\dev\\EDiscovery\\src\\TaskDistributionSystem\\ApplicationPlugins\\EDiscovery\\FastLocalSearchResultsProvider.cs");
arg2 = new FastLocalSearchResultsProvider.RecipientIdentityResolver(tenantOrRootOrgRecipientSession);
IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, adsessionSettings, 149, "ParseSearch", "f:\\15.00.1497\\sources\\dev\\EDiscovery\\src\\TaskDistributionSystem\\ApplicationPlugins\\EDiscovery\\FastLocalSearchResultsProvider.cs");
arg = new PolicyTagAdProvider(tenantOrTopologyConfigurationSession);
}
queryFilter = func(arg2, arg);
}
if (queryFilter != null)
{
definition.Query = FqlQueryBuilder.ToFqlString(queryFilter, culture);
}
}, TimeSpan.FromMinutes(1.0), out faultDefinition, target, null, default(CancellationToken), null, "ParseSearch", "f:\\15.00.1497\\sources\\dev\\EDiscovery\\src\\TaskDistributionSystem\\ApplicationPlugins\\EDiscovery\\FastLocalSearchResultsProvider.cs", 102);
if (faultDefinition != null)
{
ExceptionHandler.FaultMessage(target, faultDefinition, true);
}
return(definition);
}
// Token: 0x06001353 RID: 4947 RVA: 0x00077818 File Offset: 0x00075A18
public static AqsParser.ParseOption GetAqsParseOption(Folder folder, bool isContentIndexingEnabled)
{
AqsParser.ParseOption parseOption = AqsParser.ParseOption.SuppressError;
if (!isContentIndexingEnabled)
{
parseOption |= AqsParser.ParseOption.ContentIndexingDisabled;
}
bool flag = Array.Exists <string>(SearchFilterGenerator.prefixAllowedFolderList, (string item) => string.Equals(item, folder.ClassName, StringComparison.OrdinalIgnoreCase));
flag |= (folder is SearchFolder || folder.Session is PublicFolderSession);
if (Globals.DisablePrefixSearch && !flag)
{
parseOption |= AqsParser.ParseOption.DisablePrefixMatch;
}
return(parseOption);
}
public static QueryFilter ParseAndBuildQuery(string query, AqsParser.ParseOption parseOption, CultureInfo culture, IRecipientResolver recipientResolver, IPolicyTagProvider policyTagProvider)
{
return(AqsParser.ParseAndBuildQuery(query, parseOption, culture, RescopedAll.Default, recipientResolver, policyTagProvider));
}
internal Condition Parse(string query, AqsParser.ParseOption parseOption, CultureInfo cultureInfo)
{
if (query == null)
{
throw new ArgumentNullException("query");
}
if (cultureInfo == null)
{
throw new ArgumentNullException("cultureInfo");
}
this.parseOption = parseOption;
if (this.SupportNqs && !this.SuppressError)
{
throw new ArgumentException("parserOption: NQS must be combined with SuppressError");
}
if (this.UseCiKeywordOnly && this.UseBasicKeywordOnly)
{
throw new ArgumentException("UseBasicKeywordOnly can not be combined with UseCIKeywordOnly");
}
if (this.UseCiKeywordOnly)
{
this.AllowedKeywords = PropertyKeywordHelper.CiPropertyKeywords;
}
else if (this.UseBasicKeywordOnly)
{
this.AllowedKeywords = PropertyKeywordHelper.BasicPropertyKeywords;
}
Condition result;
try
{
int num = 0;
int i = 0;
while (i < query.Length)
{
char c = query[i];
if (c == '(' && ++num > 50)
{
if (this.SuppressError)
{
return(null);
}
throw new ParserException(new ParserErrorInfo(ParserErrorCode.ParserError));
}
else
{
i++;
}
}
using (ParserManager parserManager = new ParserManager())
{
using (Parser parser = parserManager.CreateLoadedParser(cultureInfo))
{
parserManager.InitializeOptions(this.SupportNqs, !this.DisablePrefixMatch, parser);
using (Solution solution = parser.Parse(query))
{
List <ParserErrorInfo> list = new List <ParserErrorInfo>();
if (!this.SuppressError)
{
this.PreResolvingValidate(solution, list);
if (list.Count > 0)
{
throw new ParserException(list);
}
}
ResolveOptions resolveOptions = 0;
if (!this.SplitWords)
{
resolveOptions |= 64;
}
Condition condition = solution.Resolve(solution.Condition, resolveOptions, (DateTime)ExDateTime.Now);
if (condition == null && !this.SuppressError)
{
throw new ParserException(new ParserErrorInfo(ParserErrorCode.ParserError));
}
if (!this.SuppressError)
{
this.ValidateConditionTree(solution, condition, list, true);
if (list.Count > 0)
{
throw new ParserException(list);
}
}
result = condition;
}
}
}
}
catch (StructuredQueryException innerException)
{
if (!this.SuppressError)
{
throw new ParserException(new ParserErrorInfo(ParserErrorCode.StructuredQueryException), innerException);
}
result = null;
}
return(result);
}
