private static void GetNodeFromComparisonFilter(ComparisonFilter comparisonFilter, Hashtable allowedProperties, List <FilterNode> filterNodes, bool isNotFilter)
{
if (allowedProperties.ContainsKey(comparisonFilter.Property.Name))
{
FilterNode filterNode = new FilterNode();
filterNode.FilterablePropertyDescription = (FilterablePropertyDescription)allowedProperties[comparisonFilter.Property.Name];
filterNode.Operator = (PropertyFilterOperator)comparisonFilter.ComparisonOperator;
if (typeof(Enum).IsAssignableFrom(comparisonFilter.Property.Type))
{
filterNode.Value = Enum.Parse(comparisonFilter.Property.Type, comparisonFilter.PropertyValue.ToString(), true);
}
else if (typeof(bool).IsAssignableFrom(comparisonFilter.Property.Type))
{
filterNode.Value = !isNotFilter;
}
else if (comparisonFilter.Property.Type == typeof(MultiValuedProperty <string>))
{
filterNode.Value = comparisonFilter.PropertyValue.ToUserFriendText(CultureInfo.CurrentUICulture.TextInfo.ListSeparator, (object input) => false);
}
else
{
filterNode.Value = MonadFilter.ConvertValueFromString(comparisonFilter.PropertyValue, comparisonFilter.Property.Type);
}
filterNodes.Add(filterNode);
return;
}
throw new InvalidOperationException(Strings.UnknownFilterableProperty(comparisonFilter.Property.Name).ToString());
}
private void Initialize(IEnumerable <ValidationRuleDefinition> rules)
{
if (rules == null)
{
throw new ArgumentNullException("rules");
}
if (this.featuresToRules != null && this.cmdletToRules != null)
{
return;
}
lock (this.listLock)
{
if (this.featuresToRules == null || this.cmdletToRules == null)
{
this.cmdletToRules = new Dictionary <string, List <ValidationRuleDefinition> >();
this.featuresToRules = new Dictionary <string, List <ValidationRuleDefinition> >();
foreach (ValidationRuleDefinition validationRuleDefinition in rules)
{
if (validationRuleDefinition.Expressions != null && validationRuleDefinition.Expressions.Count > 0)
{
foreach (ValidationRuleExpression validationRuleExpression in validationRuleDefinition.Expressions)
{
MonadFilter monadFilter = new MonadFilter(validationRuleExpression.QueryString, null, validationRuleExpression.Schema);
validationRuleExpression.QueryFilter = monadFilter.InnerFilter;
}
}
OrganizationValidationRuleDefinition organizationValidationRuleDefinition = validationRuleDefinition as OrganizationValidationRuleDefinition;
if (organizationValidationRuleDefinition != null)
{
if (organizationValidationRuleDefinition.OverridingAllowExpressions != null && organizationValidationRuleDefinition.OverridingAllowExpressions.Count > 0)
{
foreach (ValidationRuleExpression validationRuleExpression2 in organizationValidationRuleDefinition.OverridingAllowExpressions)
{
MonadFilter monadFilter2 = new MonadFilter(validationRuleExpression2.QueryString, null, validationRuleExpression2.Schema);
validationRuleExpression2.QueryFilter = monadFilter2.InnerFilter;
}
}
if (organizationValidationRuleDefinition.RestrictionExpressions != null && organizationValidationRuleDefinition.RestrictionExpressions.Count > 0)
{
foreach (ValidationRuleExpression validationRuleExpression3 in organizationValidationRuleDefinition.RestrictionExpressions)
{
MonadFilter monadFilter3 = new MonadFilter(validationRuleExpression3.QueryString, null, validationRuleExpression3.Schema);
validationRuleExpression3.QueryFilter = monadFilter3.InnerFilter;
}
}
}
foreach (RoleEntry roleEntry in validationRuleDefinition.ApplicableRoleEntries)
{
string key = roleEntry.Name;
if (roleEntry is CmdletRoleEntry)
{
key = ((CmdletRoleEntry)roleEntry).FullName;
}
RBACHelper.AddValueToDictionaryList <ValidationRuleDefinition>(this.cmdletToRules, key, validationRuleDefinition);
}
RBACHelper.AddValueToDictionaryList <ValidationRuleDefinition>(this.featuresToRules, validationRuleDefinition.Feature, validationRuleDefinition);
}
}
}
}
private QueryFilter GetOPathFilter(string filterStr)
{
MonadFilter monadFilter = null;
QueryFilter result = null;
try
{
base.WriteVerbose(Strings.VerboseTryingToParseOPathFilter(filterStr));
monadFilter = new MonadFilter(filterStr, this, ObjectSchema.GetInstance <ADRecipientProperties>());
base.WriteVerbose(Strings.VerboseParsingOPathFilterSucceed(filterStr));
}
catch (InvalidCastException exception)
{
base.ThrowTerminatingError(exception, ErrorCategory.InvalidArgument, null);
}
catch (ParsingException ex)
{
base.WriteVerbose(Strings.VerboseParsingOPathFilterFailed(filterStr, ex.Message));
}
if (monadFilter != null && monadFilter.InnerFilter != null)
{
result = monadFilter.InnerFilter;
}
return(result);
}
private static object ConvertValueFromString(object valueToConvert, Type resultType)
{
string value = valueToConvert as string;
bool flag;
if (!string.IsNullOrEmpty(value) && resultType.Equals(typeof(bool)) && bool.TryParse(value, out flag))
{
return(flag);
}
return(MonadFilter.ConvertValueFromString(valueToConvert, resultType));
}
internal static bool TryConvertPowershellFilterIntoQueryFilter(string filter, ScopeRestrictionType scopeRestrictionType, Task task, out QueryFilter queryFilter, out string errorString)
{
queryFilter = null;
errorString = null;
ObjectSchema schema;
switch (scopeRestrictionType)
{
case ScopeRestrictionType.RecipientScope:
schema = RBACHelper.aDRecipientObjectsSchema;
break;
case ScopeRestrictionType.ServerScope:
schema = RBACHelper.serverSchema;
break;
case ScopeRestrictionType.PartnerDelegatedTenantScope:
schema = RBACHelper.tenantOrganizationPresentationObjectSchema;
break;
case ScopeRestrictionType.DatabaseScope:
schema = RBACHelper.databaseSchema;
break;
default:
throw new ArgumentException("scopeRestrictionType");
}
Exception ex = null;
try
{
MonadFilter monadFilter = new MonadFilter(filter, task, schema);
queryFilter = monadFilter.InnerFilter;
return(true);
}
catch (InvalidCastException ex2)
{
ex = ex2;
}
catch (ParsingException ex3)
{
ex = ex3;
}
errorString = ex.Message;
return(false);
}
public string Validate()
{
if (this.ValueParsingError != null)
{
return(string.Format("{0}: '{1}'", this.DisplayName, this.ValueParsingError));
}
string text = null;
if (this.op == PropertyFilterOperator.Equal || this.op == PropertyFilterOperator.NotEqual || this.op == PropertyFilterOperator.GreaterThan || this.op == PropertyFilterOperator.LessThan || this.op == PropertyFilterOperator.LessThanOrEqual || this.op == PropertyFilterOperator.GreaterThanOrEqual)
{
Type type = this.Value.GetType();
if (type != this.PropertyDefinition.Type)
{
try
{
string valueToConvert;
if (this.Value is DateTime)
{
valueToConvert = ((DateTime)this.Value).ToString("s");
}
else
{
valueToConvert = this.Value.ToString();
}
MonadFilter.ConvertValueFromString(valueToConvert, this.PropertyDefinition.Type);
}
catch (PSInvalidCastException ex)
{
Exception ex2 = ex;
while (ex2.InnerException != null && !(ex2.InnerException is FormatException))
{
ex2 = ex2.InnerException;
}
text = string.Format("{0}: '{1}'", this.DisplayName, (ex2.InnerException != null) ? ex2.InnerException.Message : ex.Message);
if (this.PropertyDefinition.Type == typeof(Version))
{
text = string.Format("{0}. {1}", text, Strings.ValidVersionExample);
}
}
}
}
return(text);
}
protected override void UpdateFilterProperty()
{
base.UpdateFilterProperty();
if (this.MinVersion != null)
{
QueryFilter queryFilter = new ComparisonFilter(ComparisonOperator.GreaterThanOrEqual, ADObjectSchema.ExchangeVersion, this.MinVersion);
if (!this.RecipientTypeDetailsWithoutVersionRestriction.IsNullOrEmpty())
{
QueryFilter recipientTypeDetailsFilter = RecipientIdParameter.GetRecipientTypeDetailsFilter(base.RecipientTypeDetailsList);
if (recipientTypeDetailsFilter != null)
{
queryFilter = new AndFilter(new QueryFilter[]
{
recipientTypeDetailsFilter,
queryFilter
});
}
recipientTypeDetailsFilter = RecipientIdParameter.GetRecipientTypeDetailsFilter(this.RecipientTypeDetailsWithoutVersionRestriction);
queryFilter = new OrFilter(new QueryFilter[]
{
recipientTypeDetailsFilter,
queryFilter
});
base.RecipientTypeDetailsList = null;
}
string text = (string)base["Filter"];
if (!text.IsNullOrBlank())
{
base["Filter"] = string.Empty;
MonadFilter monadFilter = new MonadFilter(text, null, ObjectSchema.GetInstance <ReducedRecipientSchema>());
queryFilter = new AndFilter(new QueryFilter[]
{
monadFilter.InnerFilter,
queryFilter
});
}
base["RecipientPreviewFilter"] = LdapFilterBuilder.LdapFilterFromQueryFilter(queryFilter);
}
}
private QueryFilter ConvertToQueryFilter(string filter)
{
MonadFilter monadFilter = new MonadFilter(filter ?? string.Empty, this, ObjectSchema.GetInstance <ADRecipientProperties>());
return(monadFilter.InnerFilter);
}
internal void InitializeInnerFilter <Schema>(string filterString, Schema queueInfoSchema) where Schema : PagedObjectSchema
{
QueryFilter filter = new MonadFilter(filterString, this, queueInfoSchema).InnerFilter;
this.innerFilter = DateTimeConverter.ConvertQueryFilter(filter);
}
