public static ValidatorGroup Parse(Stream inputStream, Dictionary <String, Object> objectStorage)
{
ValidatorRecipe recipe = new ValidatorRecipe(); // XmlTools.Read<ValidatorRecipe>(inputStream);
recipe.FromXmlStream(inputStream);
LoadKeyStores(recipe, objectStorage);
LoadBuckets(recipe, objectStorage);
Dictionary <String, IValidatorRule> rulesMap = new Dictionary <string, IValidatorRule>();
foreach (ValidatorType validatorType in recipe.Validator)
{
var rules = validatorType.ExtensibleTypeData[0].ExtensibleType_Type_Group.ToList();
IValidatorRule validatorRule = Parse(
rules,
objectStorage,
Enumerations.JunctionEnum.AND);
if (validatorType.ValidatorTypeData.Timeout != null)
{
validatorRule = new CachedValidatorRule(validatorRule);
}
String name = validatorType.ValidatorTypeData.Name == null ? "default" : validatorType.ValidatorTypeData.Name;
rulesMap.Add(name, validatorRule);
objectStorage.Add(String.Format("#validator::{0}", name), validatorRule);
}
return(new ValidatorGroup(rulesMap, recipe.Name, recipe.Version));
// } catch (JAXBException | CertificateValidationException e) {
// throw new ValidatorParsingException(e.getMessage(), e);
//}
}
public void Valid(IValidatorRule <T> validator)
{
Action <IRuleBuilder <T> > proxy = builder => builder.Validate(validator);
//void IFluentExpressionBuilder<T>.Rule(Action<IRuleBuilder<T>> action)
((IFluentExpressionBuilder <T>) this).Rule(proxy);
}
public CachedValidatorRule(IValidatorRule validatorRule)
{
this.validatorRule = validatorRule;
this.memoryCache = new MemoryCache(
new MemoryCacheOptions()
{
ExpirationScanFrequency = TimeSpan.FromSeconds(5)
}
);
}
void IRuleBuilder <T> .Validate(IValidatorRule <T> validator)
{
this.evaluatorx = validator;
string name = validator.GetType().Name;
this.rule = new LogicDefine.Rule()
{
Id = name, TrueCondition = true
};
}
private IReadOnlyCollection <HttpError> ValidateRequest(IValidatorRule[] validatorRules = null)
{
if (validatorRules == null)
{
validatorRules = new IValidatorRule[] {
new ExistsInTable("item_guid", "items", "guid"),
};
}
var errors = ValidationProcessor.Process(Request, validatorRules);
return(errors);
}
public void AddRule(string fieldName, IValidatorRule rule)
{
if (_rules.ContainsKey(fieldName))
{
_rules[fieldName].Add(rule);
}
else
{
_rules.Add(fieldName, new List <IValidatorRule> {
rule
});
}
}
public void ValidateWithContext(IValidatorRule <T> validator, Action <ContextBuilder> context)
{
((IRuleBuilder <T>) this).Validate(validator);
ContextBuilder builder = new ContextBuilder();
if (context == null)
{
throw new ArgumentException("Caller failed to provide context");
}
context.Invoke(builder);
builderRef.workflowManager.AddContextDefinition(builder.builder.definition);
this.rule.Context = builder.context;
}
/// <summary>
/// Append validator instance to validator.
/// </summary>
/// <param name="validatorRule">Configured validator.</param>
/// <returns>Builder instance.</returns>
public ValidatorBuilder AddRule(IValidatorRule validatorRule)
{
this.validatorRules.Add(validatorRule);
return(this);
}
public Validator(IValidatorRule validatorRule)
{
this.validatorRule = validatorRule;
}
