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