public override IStatebleItem CreatePropertyState(IStateble owner, string propertyName, IPropertySettingsInfo information, string uiContext, System.Globalization.CultureInfo culture)
{
var args = new StatebleItemCreatorEventArgs();
args.Identifier = information.Identifier;
args.PropertyName = propertyName;
args.CopyValue = information.CopyValue;
args.ReloadSettings = information.ReloadSettings;
var labelInfo = GetLabel(owner.Type, uiContext, propertyName);
if (labelInfo != null)
{
args.Label = labelInfo.Label;
}
else
{
args.Label = new PropertyLabel(propertyName.GetFormatter(), null);
}
var result = new Lazy <IStatebleItem>(() => CreateStatebleItem(owner, args));
var aggregateValidator = new Validators.AggregateValidator();
if (information.InputRulesGroupId.HasValue)
{
var rules = Settings.GetRules(information.InputRulesGroupId.Value, uiContext);
if (rules != null)
{
args.Options = rules.Options;
if ((args.Options & InputRulesOptions.Necessary) == InputRulesOptions.Necessary)
{
aggregateValidator.Add(ValidationManager.NecessaryValidator);
}
if (!string.IsNullOrEmpty(rules.Label))
{
args.Label = new PropertyLabel(rules.Label.GetFormatter(), rules.Label.GetFormatter());
}
if (rules.ParseId.HasValue)
{
args.Parse = CreateParse(rules.ParseId.Value);
}
if (rules.InputValidateUid.HasValue)
{
InsertValidate(result.Value, aggregateValidator, rules.InputValidateUid.Value);
}
}
}
if ((information.ValidationId.HasValue) && (information.ValidationId > 0))
{
var validator = GetValidator(information.ValidationId.Value, culture);
if (validator != null)
{
aggregateValidator.Add(validator);
}
}
if (aggregateValidator.Count > 0)
{
result.Value.Validation = aggregateValidator;
}
return(result.Value);
}
/// <summary>
/// Insere as validações de entrada na propriedade.
/// </summary>
/// <param name="propertryState">Estado atual da propriedade</param>
/// <param name="aggregateValidator">Agregador</param>
/// <param name="inputValidateUid">Identificador da validação que será incluída.</param>
private void InsertValidate(IStatebleItem propertryState, Validators.AggregateValidator aggregateValidator, Guid inputValidateUid)
{
var inputValidate = Settings.GetInputValidate(inputValidateUid);
if (inputValidate != null)
{
CalculateInputValidateInfo(propertryState, inputValidate, aggregateValidator, new List <Guid>());
}
}
/// <summary>
/// Carrega as informações de validação de entrada para um grupo de regra de entrada específico.
/// </summary>
/// <param name="inputRulesGroupId"></param>
/// <param name="uiContext"></param>
/// <returns></returns>
public override IInputValidationInfo GetInputValidateInfo(int inputRulesGroupId, string uiContext)
{
var result = new InputValidationInfo();
InputValidate inputValidate = Settings.GetInputValidate(inputRulesGroupId, uiContext);
if (inputValidate != null)
{
var aggregateValidator = new Validators.AggregateValidator();
CalculateInputValidateInfo(result, inputValidate, aggregateValidator, new List <Guid>());
}
return(result);
}
/// <summary>
/// Calcula as informações de um Inputvalidate.
/// </summary>
/// <param name="info"></param>
/// <param name="inputValidate"></param>
/// <param name="aggregateValidator"></param>
/// <param name="ignoreUids">Identificador da validações que deve ser ignoradas</param>
private void CalculateInputValidateInfo(IInputValidationInfo info, InputValidate inputValidate, Validators.AggregateValidator aggregateValidator, IList <Guid> ignoreUids)
{
if (inputValidate != null && !ignoreUids.Contains(inputValidate.Uid))
{
ignoreUids.Add(inputValidate.Uid);
switch (inputValidate.Type)
{
case InputValidateType.CharacterUpperCase:
info.CharCase = CharacterCase.Upper;
break;
case InputValidateType.CharacterLowerCase:
info.CharCase = CharacterCase.Lower;
break;
case InputValidateType.Customization:
info.Customization = inputValidate.Customization;
if (info.Customization != null)
{
aggregateValidator.Add(new Validators.CustomizationValidator(info.Customization));
}
break;
case InputValidateType.CheckDigits:
info.CheckDigits = inputValidate.CheckDigits;
if (info.CheckDigits != null)
{
aggregateValidator.Add(new Validators.CheckDigitsValidator(info.CheckDigits));
}
break;
case InputValidateType.DefaultValue:
info.DefaultValue = inputValidate.Default;
break;
case InputValidateType.Group:
foreach (var i in inputValidate.Group.Items.Select(f => Settings.InputValidates.FirstOrDefault(x => x.Uid == f.InputValidateUid)).Where(f => f != null))
{
CalculateInputValidateInfo(info, i, aggregateValidator, ignoreUids);
}
break;
case InputValidateType.IndexedValues:
info.IndexedValues = inputValidate.IndexedValues;
break;
case InputValidateType.Length:
info.Length = inputValidate.Length;
if (info.Length != null)
{
aggregateValidator.Add(new Validators.LengthValidator(info.Length));
}
break;
case InputValidateType.Mask:
info.Mask = inputValidate.Mask;
break;
case InputValidateType.Range:
info.Range = inputValidate.Range;
if (info.Range != null)
{
aggregateValidator.Add(new Validators.RangeValidator(info.Range));
}
break;
case InputValidateType.ValidChars:
info.ValidChars = inputValidate.ValidChars;
if (info.ValidChars != null)
{
aggregateValidator.Add(new Validators.ValidCharsValidator(info.ValidChars));
}
break;
case InputValidateType.Values:
info.Values = inputValidate.Values;
break;
}
}
}
