private static ValidationRule Create(ValidationRuleDefinition definition, RoleEntry roleEntry)
{
ExTraceGlobals.PublicCreationAPITracer.TraceDebug <string, string>((long)definition.GetHashCode(), "Entering ValidationRuleFactory.GetValidationRule({0}) - Creating ValidationRule. Name: '{1}'", (null == roleEntry) ? "<NULL>" : roleEntry.ToString(), definition.Name);
OrganizationValidationRuleDefinition organizationValidationRuleDefinition = definition as OrganizationValidationRuleDefinition;
if (organizationValidationRuleDefinition != null)
{
return(new OrganizationValidationRule(organizationValidationRuleDefinition, roleEntry));
}
IEnumerable <Capability> restrictedCapabilities = definition.RestrictedCapabilities;
List <CapabilityIdentifierEvaluator> list = new List <CapabilityIdentifierEvaluator>();
foreach (Capability capability in restrictedCapabilities)
{
list.Add(CapabilityIdentifierEvaluatorFactory.Create(capability));
}
IEnumerable <Capability> overridingAllowCapabilities = definition.OverridingAllowCapabilities;
List <CapabilityIdentifierEvaluator> list2 = new List <CapabilityIdentifierEvaluator>();
foreach (Capability capability2 in overridingAllowCapabilities)
{
list2.Add(CapabilityIdentifierEvaluatorFactory.Create(capability2));
}
if (definition.Expressions == null)
{
return(new RestrictedValidationRule(definition, list, list2, roleEntry));
}
return(new ExpressionFilterValidationRule(definition, list, list2, roleEntry));
}
internal void PopulateCapabilitiesProperty()
{
this.Capabilities = CapabilityIdentifierEvaluatorFactory.GetCapabilities(this);
}
private QueryFilter GetCapabilitiesFilter()
{
QueryFilter result = null;
if (this.Capabilities != null && this.Capabilities.Count > 0)
{
List <QueryFilter> list = new List <QueryFilter>(this.Capabilities.Count);
foreach (Capability capability in this.Capabilities)
{
if (capability == Capability.None)
{
base.WriteError(new NotImplementedException(DirectoryStrings.CannotBuildCapabilityFilterUnsupportedCapability(capability.ToString())), ErrorCategory.InvalidArgument, null);
}
else
{
CapabilityIdentifierEvaluator capabilityIdentifierEvaluator = CapabilityIdentifierEvaluatorFactory.Create(capability);
QueryFilter item;
LocalizedString value;
if (capabilityIdentifierEvaluator.TryGetFilter(base.CurrentOrganizationId, out item, out value))
{
list.Add(item);
}
else
{
base.WriteError(new ArgumentException(value), ErrorCategory.InvalidArgument, null);
}
}
}
result = QueryFilter.AndTogether(list.ToArray());
}
return(result);
}
