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; }