protected virtual Task ValidateOptionsAsync <TFieldType>(FormValidationContext context)
where TFieldType : class, IHasOptions, new()
{
var fields = context.FormDefinition.Fields.Where(_ => _ is TFieldType)
?.Select(_ => _ as TFieldType);
if (fields.IsNullOrEmpty())
{
return(Task.CompletedTask);
}
foreach (var field in fields)
{
if (field.Options.IsNullOrEmpty())
{
if (field.OptionsFunc == null)
{
context.SetError("field options func is required if options is numm or empty.");
return(Task.CompletedTask);
}
}
}
return(Task.CompletedTask);
}
private static bool DefaultFieldIsValid(FormValidationContext validationContext, out ValidationResult result)
{
if (validationContext.Rule.Type == FormFieldType.Array && validationContext.Rule.DefaultField != null)
{
Array values = validationContext.Value as Array;
var context = new FormValidationContext()
{
ValidateMessages = validationContext.ValidateMessages,
Rule = validationContext.Rule.DefaultField,
FieldName = validationContext.FieldName,
};
int index = 0;
foreach (var value in values)
{
context.Value = value;
context.DisplayName = $"{validationContext.DisplayName}[{index}]";
result = GetValidationResult(context);
if (result != null)
{
return(false);
}
index++;
}
}
result = null;
return(true);
}
protected virtual Task ValidateUploadAsync(FormValidationContext context)
{
var uploads = context.FormDefinition.Fields.Where(_ => _ is UploaderField)?.Select(_ => _ as UploaderField);
if (uploads.IsNullOrEmpty())
{
return(Task.CompletedTask);
}
foreach (var upload in uploads)
{
if (upload.AllowFileTypes.IsNullOrEmpty())
{
context.SetError("allow file types is empty");
return(Task.CompletedTask);
}
if (upload.IsMultiple && upload.CountLimit <= 0)
{
context.SetError("is multiple set true, but count limit is 0 or negative");
return(Task.CompletedTask);
}
}
return(Task.CompletedTask);
}
public async Task Fields_has_no_element_should_be_invalid()
{
var form = new Form
{
Key = "test",
Fields = new List <Field>()
};
var context = new FormValidationContext(form);
await validator.ValidateAsync(context);
context.IsValid.Should().BeFalse();
}
public async Task Fields_is_null_should_be_invalid()
{
var form = new Form
{
Key = "test",
Fields = null
};
var context = new FormValidationContext(form);
await validator.ValidateAsync(context);
context.IsValid.Should().BeFalse();
}
public async Task Valid_should_success()
{
var forms = TestData.FormDefinitions;
foreach (var form in forms)
{
var context = new FormValidationContext(form);
await validator.ValidateAsync(context);
context.IsValid.Should().BeTrue();
}
}
public async Task <Form> GetByKeyAsync(string formId)
{
var form = forms.SingleOrDefault(_ => _.Key == formId);
var context = new FormValidationContext(form);
await formValidator.ValidateAsync(context);
if (!context.IsValid)
{
throw new ArgumentException(context.ErrorMessage);
}
return(form);
}
public static ValidationResult GetValidationResult(FormValidationContext validationContext)
{
validationContext.Value = validationContext.Rule.Transform(validationContext.Value);
ValidationResult result;
if (!RequiredIsValid(validationContext, out result))
{
return(result);
}
if (!TypeIsValid(validationContext, out result))
{
return(result);
}
if (!LenIsValid(validationContext, out result))
{
return(result);
}
if (!MinIsValid(validationContext, out result))
{
return(result);
}
if (!MaxIsValid(validationContext, out result))
{
return(result);
}
if (!PatternIsValid(validationContext, out result))
{
return(result);
}
if (!ValidatorIsValid(validationContext, out result))
{
return(result);
}
if (!DefaultFieldIsValid(validationContext, out result))
{
return(result);
}
if (!FieldsIsValid(validationContext, out result))
{
return(result);
}
if (!OneOfIsValid(validationContext, out result))
{
return(result);
}
return(null);
}
public async Task Field_name_is_missing_should_be_invalid()
{
var form = new Form
{
Key = "test",
Fields = new List <Field>
{
new TextboxField {
FieldName = ""
}
}
};
var context = new FormValidationContext(form);
await validator.ValidateAsync(context);
context.IsValid.Should().BeFalse();
}
public async Task Checkbox_options_is_null_and_options_store_provided_should_be_valid()
{
var form = new Form
{
Key = "test",
Fields = new List <Field>
{
new CheckboxField {
FieldName = "test", Options = new List <Option>(), OptionsFunc = str => new List <Option>()
}
}
};
var context = new FormValidationContext(form);
await validator.ValidateAsync(context);
context.IsValid.Should().BeTrue();
}
public async Task Uploader_allow_file_types_is_empty_should_be_invalid()
{
var form = new Form
{
Key = "test",
Fields = new List <Field>
{
new UploaderField {
FieldName = "test", AllowFileTypes = new List <string>()
}
}
};
var context = new FormValidationContext(form);
await validator.ValidateAsync(context);
context.IsValid.Should().BeFalse();
}
public async Task Select_option_is_empty_should_be_invalid()
{
var form = new Form
{
Key = "test",
Fields = new List <Field>
{
new SelectField {
FieldName = "test", Options = new List <Option>()
}
}
};
var context = new FormValidationContext(form);
await validator.ValidateAsync(context);
context.IsValid.Should().BeFalse();
}
public async Task Radio_option_is_null_should_be_invalid()
{
var form = new Form
{
Key = "test",
Fields = new List <Field>
{
new RadioField {
FieldName = "test", Options = null
}
}
};
var context = new FormValidationContext(form);
await validator.ValidateAsync(context);
context.IsValid.Should().BeFalse();
}
private static bool ValidatorIsValid(FormValidationContext validationContext, out ValidationResult result)
{
var rule = validationContext.Rule;
if (rule.Validator != null)
{
result = rule.Validator(validationContext);
if (result != null)
{
return(false);
}
}
result = null;
return(true);
}
private static bool TypeIsValid(FormValidationContext validationContext, out ValidationResult result)
{
var rule = validationContext.Rule;
var attribute = new TypeAttribute(rule.Type);
attribute.ErrorMessage = validationContext.ValidateMessages.GetTypeMessage(rule.Type);
if (!IsValid(attribute, validationContext, out ValidationResult validationResult))
{
result = validationResult;
return(false);
}
result = null;
return(true);
}
private static bool RequiredIsValid(FormValidationContext validationContext, out ValidationResult result)
{
if (validationContext.Rule.Required == true)
{
var attribute = new RequiredAttribute();
attribute.ErrorMessage = validationContext.ValidateMessages.Required;
if (!IsValid(attribute, validationContext, out ValidationResult validationResult))
{
result = validationResult;
return(false);
}
}
result = null;
return(true);
}
private static bool IsValid(ValidationAttribute validationAttribute, FormValidationContext validationContext, out ValidationResult result)
{
if (validationAttribute.IsValid(validationContext.Value) == false)
{
if (validationContext.Rule.Message != null)
{
validationAttribute.ErrorMessage = validationContext.Rule.Message;
}
string errorMessage = validationAttribute.FormatErrorMessage(validationContext.DisplayName);
result = new ValidationResult(errorMessage, new string[] { validationContext.FieldName });
return(false);
}
result = null;
return(true);
}
public async Task AddAsync(Form form)
{
if (form == null)
{
throw new ArgumentNullException(nameof(form));
}
if (forms.Any(_ => _.Key == form.Key))
{
throw new ArgumentException("form id already exist");
}
var context = new FormValidationContext(form);
await formValidator.ValidateAsync(context);
if (!context.IsValid)
{
throw new ArgumentException(context.ErrorMessage);
}
forms.Add(form);
}
private static bool PatternIsValid(FormValidationContext validationContext, out ValidationResult result)
{
var rule = validationContext.Rule;
if (!string.IsNullOrEmpty(rule.Pattern))
{
var attribute = new RegularExpressionAttribute(rule.Pattern);
attribute.ErrorMessage = validationContext.ValidateMessages.Pattern.Mismatch;
if (!IsValid(attribute, validationContext, out ValidationResult validationResult))
{
result = validationResult;
return(false);
}
}
result = null;
return(true);
}
public async Task ValidateAsync(FormValidationContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
await ValidateFormDefinitionAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateFieldsAsync(context);
if (!context.IsValid)
{
return;
}
}
private static bool OneOfIsValid(FormValidationContext validationContext, out ValidationResult result)
{
var rule = validationContext.Rule;
if (rule.Type != FormFieldType.Array && rule.OneOf != null)
{
var attribute = new OneOfAttribute(rule.OneOf);
attribute.ErrorMessage = validationContext.ValidateMessages.OneOf;
if (!IsValid(attribute, validationContext, out ValidationResult validationResult))
{
result = validationResult;
return(false);
}
}
result = null;
return(true);
}
public async Task Uploader_allow_multiple_and_limit_count_is_zero_or_negative_should_be_invalid()
{
var form = new Form
{
Key = "test",
Fields = new List <Field>
{
new UploaderField
{
FieldName = "test",
AllowFileTypes = new List <string> {
"jpg"
},
IsMultiple = true
}
}
};
var context = new FormValidationContext(form);
await validator.ValidateAsync(context);
context.IsValid.Should().BeFalse();
}
private static bool MaxIsValid(FormValidationContext validationContext, out ValidationResult result)
{
var rule = validationContext.Rule;
if (rule.Max != null)
{
ValidationAttribute attribute = null;
if (rule.Type.IsIn(FormFieldType.String))
{
attribute = new MaxLengthAttribute((int)rule.Max);
attribute.ErrorMessage = validationContext.ValidateMessages.String.Max;
}
if (rule.Type.IsIn(FormFieldType.Array))
{
attribute = new MaxLengthAttribute((int)rule.Max);
attribute.ErrorMessage = validationContext.ValidateMessages.Array.Max;
}
if (rule.Type.IsIn(FormFieldType.Number, FormFieldType.Integer, FormFieldType.Float))
{
attribute = new NumberMaxAttribute((decimal)rule.Max);
attribute.ErrorMessage = validationContext.ValidateMessages.Number.Max;
}
if (attribute != null && !IsValid(attribute, validationContext, out ValidationResult validationResult))
{
result = validationResult;
return(false);
}
}
result = null;
return(true);
}
protected virtual Task ValidateFormDefinitionAsync(FormValidationContext context)
{
var form = context.FormDefinition;
if (form == null)
{
context.SetError("form is null");
return(Task.CompletedTask);
}
if (form.Key.IsMissing())
{
context.SetError("form id is missing");
return(Task.CompletedTask);
}
if (form.Fields.IsNullOrEmpty())
{
context.SetError("fields is empty");
return(Task.CompletedTask);
}
return(Task.CompletedTask);
}
private static bool LenIsValid(FormValidationContext validationContext, out ValidationResult result)
{
var rule = validationContext.Rule;
if (rule.Len != null)
{
ValidationAttribute attribute = null;
if (rule.Type == FormFieldType.String)
{
attribute = new StringLengthAttribute((int)rule.Len);
attribute.ErrorMessage = validationContext.ValidateMessages.String.Len;
}
if (rule.Type == FormFieldType.Number)
{
attribute = new NumberAttribute((decimal)rule.Len);
attribute.ErrorMessage = validationContext.ValidateMessages.Number.Len;
}
if (rule.Type == FormFieldType.Array)
{
attribute = new ArrayLengthAttribute((int)rule.Len);
attribute.ErrorMessage = validationContext.ValidateMessages.Array.Len;
}
if (attribute != null && !IsValid(attribute, validationContext, out ValidationResult validationResult))
{
result = validationResult;
return(false);
}
}
result = null;
return(true);
}
protected virtual Task ValidateColorPickerAsync(FormValidationContext context)
{
return(Task.CompletedTask);
}
protected async virtual Task ValidateCascaderAsync(FormValidationContext context)
{
await ValidateOptionsAsync <CascaderField>(context);
}
protected virtual Task ValidateSwitchAsync(FormValidationContext context)
{
return(Task.CompletedTask);
}
protected async virtual Task ValidateFieldsAsync(FormValidationContext context)
{
var fields = context.FormDefinition.Fields;
if (fields.Any(_ => _.FieldName.IsMissing()))
{
context.SetError("field name is missing");
return;
}
if (fields.HasDuplicates(_ => _.FieldName))
{
context.SetError("field name has duplicates");
}
await ValidateCheckBoxAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateDateBoxAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateDateTimeBoxAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateDecimalBoxAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateIntBoxAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateMultiSelectAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateRadioAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateRichTextAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateSelectAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateTextAreaAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateTextBoxAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateTimeAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateCascaderAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateColorPickerAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateSliderAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateSwitchAsync(context);
if (!context.IsValid)
{
return;
}
await ValidateUploadAsync(context);
if (!context.IsValid)
{
return;
}
}
private static bool FieldsIsValid(FormValidationContext validationContext, out ValidationResult result)
{
var rule = validationContext.Rule;
if (!rule.Type.IsIn(FormFieldType.Array, FormFieldType.Object) || rule.Fields == null)
{
result = null;
return(true);
}
var context = new FormValidationContext()
{
ValidateMessages = validationContext.ValidateMessages,
DisplayName = validationContext.DisplayName,
FieldName = validationContext.FieldName,
};
Array arrValues = validationContext.Value as Array;
var objectType = validationContext.Value.GetType();
foreach (var key in rule.Fields.Keys)
{
if (rule.Type == FormFieldType.Array)
{
int index = (int)key;
// out of range, ignore validation
if (index >= arrValues.Length)
{
continue;
}
context.Value = arrValues.GetValue(index);
context.DisplayName = $"{validationContext.DisplayName}[{index}]";
}
else
{
var propertyValue = objectType.GetProperty(key.ToString());
if (propertyValue != null)
{
context.Value = propertyValue.GetValue(validationContext.Value);
}
else
{
var fieldValue = objectType.GetField(key.ToString());
// field not exists, ignore validation
if (fieldValue == null)
{
continue;
}
context.Value = fieldValue.GetValue(validationContext.Value);
}
context.DisplayName = $"{validationContext.DisplayName}.{key}";
}
context.Rule = rule.Fields[key];
result = GetValidationResult(context);
if (result != null)
{
return(false);
}
}
result = null;
return(true);
}
