protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
var results = new List<ValidationResult>();
CompositeValidationResult compositeResults = null;
foreach (var o in (IEnumerable)value)
{
var context = new ValidationContext(o, null, null);
Validator.TryValidateObject(o, context, results, true);
if (results.Count != 0)
{
if (compositeResults == null)
compositeResults = new CompositeValidationResult(String.Format("Validation for '{0}' failed", validationContext.DisplayName));
results.ForEach(compositeResults.AddResult);
results.Clear();
}
}
if (compositeResults != null)
throw new ValidationException(string.Format("Validation for '{0}' failed", validationContext.DisplayName),
new AggregateException(compositeResults.Results.Select(r => new ValidationException(r.ErrorMessage))));
return ValidationResult.Success;
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
var results = new List<ValidationResult>();
var context = new ValidationContext(value, null, null);
Validator.TryValidateObject(value, context, results, true);
if (results.Count != 0)
{
var compositeResults = new CompositeValidationResult(String.Format("Validation for {0} failed!", validationContext.DisplayName));
results.ForEach(compositeResults.AddResult);
return compositeResults;
}
return ValidationResult.Success;
}
/// <summary>
/// Validates the specified entity with respect to the current validation attribute.
/// </summary>
/// <param name="entity">The entity to validate.</param>
/// <param name="validationContext">The context information about the validation operation.</param>
/// <returns>
/// An instance of the <see cref="T:System.ComponentModel.DataAnnotations.ValidationResult" /> class.
/// </returns>
protected override ValidationResult IsValid(object entity, ValidationContext validationContext)
{
var displayName = validationContext.DisplayName;
var compositeResults = new CompositeValidationResult(string.Format("Validation for {0} failed!", displayName));
if (entity is IEnumerable)
{
IEnumerable items = (IEnumerable)entity;
var index = 0;
foreach (var item in items)
{
var validator = new DataAnnotationValidator();
validator.TryValidate(item);
var results = validator.ValidationResults;
if (results.Count != 0)
{
results.ForEach(x => compositeResults.AddResult(x, displayName, index));
}
index++;
}
return compositeResults;
}
else
{
var validator = new DataAnnotationValidator();
validator.TryValidate(entity);
var results = validator.ValidationResults;
if (results.Count != 0)
{
results.ForEach(x => compositeResults.AddResult(x, displayName));
return compositeResults;
}
}
return ValidationResult.Success;
}
protected virtual void ValidateFragmentType(CompositeValidationResult result, CompositeModel compositeModel, Type fragmentType)
{
if (!fragmentType
#if WINDOWS_PHONE_APP
.GetTypeInfo()
#endif
.IsClass)
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("Fragments must be classes; the fragment " + fragmentType + " however is not a class.", compositeModel));
}
else
{
var baseTypes = new HashSet <Type>(fragmentType.GetAllParentTypes());
baseTypes.Remove(fragmentType);
if (fragmentType
#if WINDOWS_PHONE_APP
.GetTypeInfo()
#endif
.IsAbstract)
{
foreach (var fMethod in fragmentType.GetAllInstanceMethods())
{
if (fMethod.IsAbstract && !compositeModel.Methods.Any(cMethod => AreSameFragmentMethods(fMethod, ReflectionHelper.FindMethodImplicitlyImplementingMethod(fragmentType, cMethod.NativeInfo))))
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("Found abstract method " + fMethod + " in " + fragmentType + ", with no corresponding composite method.", compositeModel));
}
}
}
foreach (var baseType in baseTypes)
{
if (baseType.IsGenericType())
{
var baseTypeGDef = baseType.GetGenericTypeDefinition();
if (compositeModel.GetAllCompositeTypes().Except(compositeModel.PublicTypes).SelectMany(cType => cType.GetAllParentTypes()).Any(pType => pType.GetGenericDefinitionIfGenericType().Equals(baseTypeGDef)) &&
baseType.GetGenericArguments().Any(gArg => gArg.IsArray || gArg.IsByRef || gArg.IsPointer))
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("Fragment type implements composite type with either array, by ref or pointer generic argument. This is not allowed, as fragment might not be instantiatable in cases of non-array or non-by-ref or non-pointer generic argument of composite type.", compositeModel));
}
}
}
}
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
this.ValidationContext = validationContext;
var results = new List <ValidationResult>();
try
{
var isIterable = this.IsIterable(value);
if (isIterable)
{
int currentItemPosition = -1;
foreach (var objectToValidate in value as IEnumerable <object> )
{
currentItemPosition++;
var resultTemp = ValidationsForObject(objectToValidate, true, currentItemPosition);
if (resultTemp != null)
{
results.AddRange(resultTemp);
}
}
if (results.Count <= 0)
{
results = null;
}
}
else
{
results = ValidationsForObject(value);
}
if (results != null)
{
//Build a validation result
List <string> memberNames = new List <string>();
results.ForEach(r => memberNames.AddRange(r.MemberNames));
var compositeResultsReturn = new CompositeValidationResult($"Validation for {validationContext.DisplayName} failed!", memberNames.AsEnumerable());
results.ForEach(r => compositeResultsReturn.AddResult(r));
return(compositeResultsReturn);
}
}
catch (Exception) { }
return(ValidationResult.Success);
}
protected virtual void ValidateSpecialMethodModel(CompositeValidationResult result, CompositeModel compositeModel, SpecialMethodModel methodModel)
{
if (methodModel.NativeInfo.IsGenericMethodDefinition)
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("Special methods can not be generic method definitions.", compositeModel, methodModel));
}
else
{
var declType = methodModel.NativeInfo.DeclaringType;
var genName = Qi4CSGeneratedAssemblyAttribute.GetGeneratedAssemblyName(declType.GetAssembly());
if ((methodModel.NativeInfo.IsAssembly || methodModel.NativeInfo.IsFamilyAndAssembly) &&
!IsTypeVisible(declType, genName))
{
result.StructureValidationErrors.Add(ValidationErrorFactory.NewStructureError("The type " + declType + " is not visible. Consider either making it public, or internal with combination of applying " + typeof(InternalsVisibleToAttribute) + " with argument " + typeof(Qi4CSGeneratedAssemblyAttribute) + ".ASSEMBLY_NAME to the assembly.", compositeModel, methodModel));
}
foreach (var pModel in methodModel.Parameters)
{
this.ValidateParameter(result, compositeModel, pModel);
}
}
}
protected override ValidationResult IsValid(object?value, ValidationContext validationContext)
{
if (value == null)
{
return(ValidationResult.Success !);
}
var results = new List <ValidationResult>();
var context = new ValidationContext(value, validationContext, null);
Validator.TryValidateObject(value, context, results, true);
if (results.Count != 0)
{
var compositeResults = new CompositeValidationResult($"Validation for {validationContext.DisplayName} failed!", validationContext.MemberName ?? "Unknown member");
results.ForEach(compositeResults.AddResult);
return(compositeResults);
}
return(ValidationResult.Success !);
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
var collectionResults = new CompositeValidationResult(String.Format("Validation for {0} failed!",
validationContext.DisplayName));
var enumerable = value as IEnumerable;
var validators = GetValidators().ToList();
if (enumerable != null)
{
var index = 0;
foreach (var val in enumerable)
{
var results = new List <ValidationResult>();
var context = new ValidationContext(val, validationContext.ServiceContainer, null);
if (ValidationType != null)
{
Validator.TryValidateValue(val, context, results, validators);
}
else
{
Validator.TryValidateObject(val, context, results, true);
}
if (results.Count != 0)
{
var compositeResults =
new CompositeValidationResult(String.Format("Validation for {0}[{1}] failed!",
validationContext.DisplayName, index));
results.ForEach(compositeResults.AddResult);
collectionResults.AddResult(compositeResults);
}
index++;
}
}
if (collectionResults.Results.Any())
{
return(collectionResults);
}
return(ValidationResult.Success);
}
/// <inheritdoc />
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
var results = new List <ValidationResult>();
switch (value)
{
case null:
return(ValidationResult.Success);
case IEnumerable enumerable:
{
foreach (var subObject in enumerable)
{
var context = new ValidationContext(subObject, null, null);
Validator.TryValidateObject(subObject, context, results, true);
}
break;
}
default:
{
var context = new ValidationContext(value, null, null);
Validator.TryValidateObject(value, context, results, true);
break;
}
}
if (results.Count != 0)
{
var compositeResults =
new CompositeValidationResult($"Validation for {validationContext.DisplayName} failed!");
results.ForEach(compositeResults.AddResult);
return(compositeResults);
}
return(ValidationResult.Success);
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
if (value == null)
{
return(ValidationResult.Success);
}
var results = new List <ValidationResult>();
var context = new ValidationContext(value);
Validator.TryValidateObject(value, context, results, true);
CompositeValidationResult compositeResults = null;
if (results.Any())
{
compositeResults = new CompositeValidationResult(string.Format("Validation for {0} failed!", validationContext.DisplayName), new[] { validationContext.DisplayName });
results.ForEach(compositeResults.AddResult);
}
return(base.IsValid(value, validationContext));
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
var enumerable = value as IEnumerable;
var compositeResults = new CompositeValidationResult($"Validation of '{validationContext.DisplayName}' failed.");
if (enumerable == null)
{
return(ValidationResult.Success);
}
var i = 0;
foreach (var item in enumerable)
{
var itemResults = new List <ValidationResult>();
var context = new ValidationContext(item, null);
Validator.TryValidateObject(item, context, itemResults, true);
if (itemResults.Any())
{
foreach (var itemResult in itemResults)
{
compositeResults.AddResult(
itemResult is CompositeValidationResult
? itemResult
: new ValidationResult($"{context.DisplayName}[{i}]: {itemResult}"));
}
}
i++;
}
return(compositeResults.Results.Any()
? compositeResults
: ValidationResult.Success);
// If we're still here, validation was successful
}
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
// If no object present, do not fail validation (Required attribute should be present if the reference is required)
if (value == null)
{
return(ValidationResult.Success);
}
var compositeResults = new CompositeValidationResult(string.Format("Validation of '{0}' failed.", validationContext.DisplayName));
var itemResults = new List <ValidationResult>();
var context = new ValidationContext(value, null, null);
Validator.TryValidateObject(value, context, itemResults, true);
if (itemResults.Any())
{
foreach (var itemResult in itemResults)
{
if (itemResult is CompositeValidationResult)
{
compositeResults.AddResult(itemResult);
}
else
{
compositeResults.AddResult(new ValidationResult(string.Format("{0}: {1}", context.DisplayName, itemResult)));
}
}
}
if (compositeResults.Results.Any())
{
return(compositeResults);
}
// If we're still here, validation was successful
return(ValidationResult.Success);
}
protected virtual void ValidateInjectableModel(CompositeValidationResult result, CompositeModel compositeModel, AbstractInjectableModel model)
{
Int32 amount = model.GetAttributesMarkedWith(typeof(InjectionScopeAttribute)).Count;
if (amount > 1)
{
result.InjectionValidationErrors.Add(ValidationErrorFactory.NewInjectionError("Only one injection permitted for field or parameter.", model));
}
else
{
Attribute attr = model.InjectionScope;
if (attr != null)
{
InjectionService injectionService = compositeModel.ApplicationModel.InjectionService;
if (injectionService.HasFunctionalityFor(attr))
{
if (!model.IsOptional)
{
var validationResult = injectionService.InjectionPossible(model);
if (validationResult == null || !validationResult.InjectionPossible)
{
result.InjectionValidationErrors.Add(ValidationErrorFactory.NewInjectionError("Injection was not possible" + (validationResult == null ? "." : (": " + validationResult.AdditionalMessage)), model));
}
}
}
else if (!model.IsOptional)
{
result.InjectionValidationErrors.Add(ValidationErrorFactory.NewInjectionError("Could not find injection functionality for attribute " + attr + ".", model));
}
}
else if (model is FieldModel)
{
result.InternalValidationErrors.Add(ValidationErrorFactory.NewInternalError("Injection attribute was null", model));
}
}
}
/// <summary>
/// Validates the specified value with respect to the current validation attribute.
/// </summary>
/// <param name="value">The value to validate.</param>
/// <param name="validationContext">The context information about the validation operation.</param>
/// <returns>
/// An instance of the <see cref="T:System.ComponentModel.DataAnnotations.ValidationResult" /> class.
/// </returns>
protected override ValidationResult IsValid(object value, ValidationContext validationContext)
{
if (validationContext == null)
{
throw new ArgumentNullException("validationContext");
}
var results = new List<ValidationResult>();
var valuesToValidate = new List<object>();
if (value is IEnumerable)
{
valuesToValidate.AddRange((value as IEnumerable<object>));
}
foreach (var valueToValidate in valuesToValidate)
{
if (valueToValidate != null)
{
var context = new ValidationContext(valueToValidate, validationContext.ServiceContainer, validationContext.Items);
Validator.TryValidateObject(valueToValidate, context, results, true);
}
}
if (results.Count != 0)
{
var compositeResults =
new CompositeValidationResult(
string.Format(CultureInfo.InvariantCulture, "Validation for {0} failed!", validationContext.DisplayName));
results.ForEach(compositeResults.AddResult);
return compositeResults;
}
return ValidationResult.Success;
}
protected override void PostValidateModel(SPI.Model.CompositeModel compositeModel, CompositeValidationResult validationResult)
{
// Nothing to do.
}
protected abstract void PostValidateModel(CompositeModel compositeModel, CompositeValidationResult validationResult);
protected virtual void ValidateParameter(CompositeValidationResult result, CompositeModel compositeModel, ParameterModel parameterModel)
{
this.ValidateParameterType(result, compositeModel, (AbstractMemberInfoModel <MemberInfo>)parameterModel.Owner, parameterModel, parameterModel.NativeInfo.ParameterType);
this.ValidateInjectableModel(result, compositeModel, parameterModel);
}
