public void ValidateSpecificDependencyDiagram(ValidationContext context) { if (this.DomainClass == null) { context.LogError("The specific diagram class " + this.Title + " needs to reference a Domain Class.", "MissingDomainClassReference", null); //this); } }
public void Validate(ValidationAttribute attribute, object value, ValidationContext validationContext, bool isValid) { if (isValid) { attribute.Validate(value, validationContext); Assert.Equal(ValidationResult.Success, attribute.GetValidationResult(value, validationContext)); // Run the validation twice, in case attributes cache anything attribute.Validate(value, validationContext); Assert.Equal(ValidationResult.Success, attribute.GetValidationResult(value, validationContext)); } else { Assert.Throws<ValidationException>(() => attribute.Validate(value, validationContext)); Assert.NotNull(attribute.GetValidationResult(value, validationContext)); // Run the validation twice, in case attributes cache anything Assert.Throws<ValidationException>(() => attribute.Validate(value, validationContext)); Assert.NotNull(attribute.GetValidationResult(value, validationContext)); } if (!attribute.RequiresValidationContext) { Assert.Equal(isValid, attribute.IsValid(value)); // Run the validation twice, in case attributes cache anything Assert.Equal(isValid, attribute.IsValid(value)); } }
internal void ValidateNameIsUnique(ValidationContext context) { try { IEnumerable<PatternElementSchema> sameNamedElements; if (this.View != null) { // Get siblings in the owning view sameNamedElements = this.View.AllElements() .Where(element => element.Name.Equals(this.Name, System.StringComparison.OrdinalIgnoreCase)); } else { // Get siblings in the owning element sameNamedElements = this.Owner.AllElements() .Where(element => element.Name.Equals(this.Name, System.StringComparison.OrdinalIgnoreCase)); } if (sameNamedElements.Count() > 1) { context.LogError( string.Format(CultureInfo.CurrentCulture, Resources.Validate_PatternElementNameIsNotUnique, this.Name), Resources.Validate_PatternElementNameIsNotUniqueCode, this); } } catch (Exception ex) { tracer.Error( ex, Resources.ValidationMethodFailed_Error, Reflector<ExtensionPointSchema>.GetMethod(n => n.ValidateNameIsUnique(context)).Name); throw; } }
public INodeVisitor Validate(ValidationContext context) { return new EnterLeaveListener(_ => { _.Match<InlineFragment>(node => { var type = context.TypeInfo.GetLastType(); if (node.Type != null && type != null && !type.IsCompositeType()) { context.ReportError(new ValidationError( context.OriginalQuery, "5.4.1.3", InlineFragmentOnNonCompositeErrorMessage(context.Print(node.Type)), node.Type)); } }); _.Match<FragmentDefinition>(node => { var type = context.TypeInfo.GetLastType(); if (type != null && !type.IsCompositeType()) { context.ReportError(new ValidationError( context.OriginalQuery, "5.4.1.3", FragmentOnNonCompositeErrorMessage(node.Name, context.Print(node.Type)), node.Type)); } }); }); }
public INodeVisitor Validate(ValidationContext context) { return new EnterLeaveListener(_ => { _.Match<Field>(f => Field(context.TypeInfo.GetLastType(), f, context)); }); }
internal void ValidateWizardIdIsValid(ValidationContext context) { try { if (this.WizardId != Guid.Empty) { if (!this.Owner.GetAutomationSettings<IWizardSettings>().Any(c => c.Id.Equals(this.WizardId))) { if (this.Owner.IsInheritedFromBase && SettingsValidationHelper.TryToFixId<IWizardSettings>(this.Store, this.Owner, this.WizardId, id => this.WizardId = id)) { return; } context.LogError( string.Format( CultureInfo.CurrentCulture, Resources.Validate_WizardIsNotValid), Resources.Validate_WizardIsNotValidCode, this.Extends); } } } catch (Exception ex) { tracer.Error( ex, Properties.Resources.ValidationMethodFailed_Error, Reflector<TemplateSettings>.GetMethod(n => n.ValidateWizardIdIsValid(context)).Name); throw; } }
private void ValidateSpaceInPropertyName(ValidationContext context) { if (!string.IsNullOrEmpty(Name) && Name.IndexOf(" ") > 0) { context.LogError("Property names cannot contain spaces", "AW001ValidateSpaceInPropertyNameError", this); } }
public void Validate(ValidationContext context) { if (!IsValid) { context.Notification.RegisterMessage<ValidatedClass>(x => x.Name, ValidationKeys.REQUIRED); } }
/// <summary> /// Determines whether or not a rule should execute. /// </summary> /// <param name="rule">The rule</param> /// <param name="propertyPath">Property path (eg Customer.Address.Line1)</param> /// <param name="context">Contextual information</param> /// <returns>Whether or not the validator can execute.</returns> public bool CanExecute(IValidationRule rule, string propertyPath, ValidationContext context) { if (string.IsNullOrEmpty(rule.RuleSet)) return true; if (!string.IsNullOrEmpty(rule.RuleSet) && rulesetsToExecute.Length > 0 && rulesetsToExecute.Contains(rule.RuleSet)) return true; if (rulesetsToExecute.Contains("*")) return true; return false; }
/// <summary> /// Determines whether or not a rule should execute. /// </summary> /// <param name="rule">The rule</param> /// <param name="propertyPath">Property path (eg Customer.Address.Line1)</param> /// <param name="context">Contextual information</param> /// <returns>Whether or not the validator can execute.</returns> public bool CanExecute(IValidationRule rule, string propertyPath, ValidationContext context) { // By default we ignore any rules part of a RuleSet. if (!string.IsNullOrEmpty(rule.RuleSet)) return false; return true; }
public INodeVisitor Validate(ValidationContext context) { var knownFragments = new Dictionary<string, FragmentDefinition>(); return new EnterLeaveListener(_ => { _.Match<FragmentDefinition>(fragmentDefinition => { var fragmentName = fragmentDefinition.Name; if (knownFragments.ContainsKey(fragmentName)) { var error = new ValidationError( context.OriginalQuery, "5.4.1.1", DuplicateFragmentNameMessage(fragmentName), knownFragments[fragmentName], fragmentDefinition); context.ReportError(error); } else { knownFragments[fragmentName] = fragmentDefinition; } }); }); }
internal void ValidateCommandIdAndWizardIdIsNotEmpty(ValidationContext context, EventSettings settings) { Guard.NotNull(() => context, context); Guard.NotNull(() => settings, settings); try { // Ensure not empty if (settings.CommandId == Guid.Empty && settings.WizardId == Guid.Empty) { context.LogError( string.Format( CultureInfo.CurrentCulture, Resources.Validate_EventSettingsCommandIdAndWizardIdIsNotEmpty, settings.Name), Resources.Validate_EventSettingsCommandIdAndWizardIdIsNotEmptyCode, settings.Extends); } } catch (Exception ex) { tracer.Error( ex, Resources.ValidationMethodFailed_Error, Reflector<EventSettingsValidations>.GetMethod(n => n.ValidateCommandIdAndWizardIdIsNotEmpty(null, null)).Name); throw; } }
/** Re-initializes attributes. */ public void Reset( Schema schema, XmlElement e ) { XmlAttributeCollection atts = e.Attributes; count = atts.Count; if( names.Length<count ) { // reallocate the buffer names = new int[count]; values = new string[count]; } int j=0; for( int i=0; i<count; i++ ) { XmlNode att = atts.Item(i); if( att.Name=="xmlns" || att.Name.StartsWith("xmlns:") ) continue; names[j] = schema.GetNameCode( att.NamespaceURI, att.LocalName ); values[j] = att.Value; j++; } count = j; this.context = new XmlElementContext(e); }
protected override ValidationResult IsValid(object value, ValidationContext validationContext) { var memberNames = new[] {validationContext.MemberName}; PropertyInfo otherPropertyInfo = validationContext.ObjectType.GetProperty(OtherProperty); if (otherPropertyInfo == null) { return new ValidationResult(String.Format(CultureInfo.CurrentCulture, DataAnnotationsResources.EqualTo_UnknownProperty, OtherProperty), memberNames); } var displayAttribute = otherPropertyInfo.GetCustomAttributes(typeof(DisplayAttribute), false).FirstOrDefault() as DisplayAttribute; if (displayAttribute != null && !string.IsNullOrWhiteSpace(displayAttribute.Name)) { OtherPropertyDisplayName = displayAttribute.Name; } object otherPropertyValue = otherPropertyInfo.GetValue(validationContext.ObjectInstance, null); if (!Equals(value, otherPropertyValue)) { return new ValidationResult(FormatErrorMessage(validationContext.DisplayName), memberNames); } return null; }
internal void ValidateTypeNameNotEmpty(ValidationContext context) { try { // Ensure not empty if (string.IsNullOrEmpty(this.TypeName)) { context.LogError( string.Format( CultureInfo.CurrentCulture, Resources.Validate_WizardSettingsTypeIsNotEmpty, this.Name), Resources.Validate_WizardSettingsTypeIsNotEmptyCode, this.Extends); } } catch (Exception ex) { tracer.Error( ex, Resources.ValidationMethodFailed_Error, Reflector<WizardSettings>.GetMethod(n => n.ValidateTypeNameNotEmpty(context)).Name); throw; } }
public INodeVisitor Validate(ValidationContext context) { var variableNameDefined = new Dictionary<string, bool>(); return new EnterLeaveListener(_ => { _.Match<VariableDefinition>(varDef => variableNameDefined[varDef.Name] = true); _.Match<Operation>( enter: op => variableNameDefined = new Dictionary<string, bool>(), leave: op => { var usages = context.GetRecursiveVariables(op); usages.Apply(usage => { var varName = usage.Node.Name; bool found; if (!variableNameDefined.TryGetValue(varName, out found)) { var error = new ValidationError( context.OriginalQuery, "5.7.4", UndefinedVarMessage(varName, op.Name), usage.Node, op); context.ReportError(error); } }); }); }); }
public bool Validate(object model, Type type, ModelMetadataProvider metadataProvider, HttpActionContext actionContext, string keyPrefix) { if (type == null) { throw new ArgumentNullException("type"); } if (metadataProvider == null) { throw new ArgumentNullException("metadataProvider"); } if (actionContext == null) { throw new ArgumentNullException("actionContext"); } if (model != null && MediaTypeFormatterCollection.IsTypeExcludedFromValidation(model.GetType())) { // no validation for some DOM like types return true; } ModelValidatorProvider[] validatorProviders = actionContext.GetValidatorProviders().ToArray(); // Optimization : avoid validating the object graph if there are no validator providers if (validatorProviders == null || validatorProviders.Length == 0) { return true; } ModelMetadata metadata = metadataProvider.GetMetadataForType(() => model, type); ValidationContext validationContext = new ValidationContext { MetadataProvider = metadataProvider, ActionContext = actionContext, ModelState = actionContext.ModelState, Visited = new HashSet<object>(), KeyBuilders = new Stack<IKeyBuilder>(), RootPrefix = keyPrefix }; return this.ValidateNodeAndChildren(metadata, validationContext, container: null); }
private void ValidateProcessRef(ValidationContext context) { string fileName = Utilities.GetFileNameForStore(this.Store); if (fileName == "") return; IModelBus modelBus = this.Store.GetService(typeof(SModelBus)) as IModelBus; //ModelBusAdapterManager manager = modelBus.FindAdapterManagers(fileName).First(); // ModelBusReference reference = manager.CreateReference(fileName); //ModelBusAdapter adapter = modelBus.CreateAdapter(this.ProcessRef); if (this.ProcessRef == null) { string error = string.Format(System.Globalization.CultureInfo.CurrentUICulture, CustomCode.Validation.ValidationResources.EmptyNameError, "Process Reference"); context.LogError("SubProcess: " + error, "ModelBus", this); return; } /*var process = adapter.ResolveElementReference(this.ProcessRef); if (process == null) { string error = string.Format(System.Globalization.CultureInfo.CurrentUICulture, CustomCode.Validation.ValidationResources.ProcessNotExist, "Process Reference"); context.LogError("SubProcess: " + error, "ModelBus", this); return; }*/ }
public static void Validate(ValidationElementState state, ValidationContext context, ModelElement currentElement) { Guard.ArgumentNotNull(context, "context"); Guard.ArgumentNotNull(currentElement, "currentElement"); if (ShouldAbortValidation(context)) { return; } try { InitializeFactory(context); if (validatorFactory != null) { DoValidate(currentElement, context, CommonRuleSet); DoValidate(currentElement, context, context.Categories.ToString()); ShowStatus(currentElement); return; } // trace when no config service context.LogWarning(Resources.NoValidationServiceAvailable, Constants.ValidationCode, currentElement); } catch (Exception ex) { context.LogFatal(LogEntry.ErrorMessageToString(ex), Constants.ValidationCode, currentElement); Trace.TraceError(ex.ToString()); } }
internal void ValidateArtifactReferences(ValidationContext context, IProductElement element) { if (this.UriReferenceService == null) { return; } try { var references = SolutionArtifactLinkReference.GetReferenceValues(element); foreach (var reference in references) { if (this.UriReferenceService.TryResolveUri<IItemContainer>(reference) == null) { context.LogError( string.Format(CultureInfo.InvariantCulture, Properties.Resources.Validate_ArtifactReferenceNotFound, element.InstanceName, reference.ToString(), ReflectionExtensions.DisplayName(typeof(SolutionArtifactLinkReference))), Properties.Resources.Validate_ArtifactReferenceNotFoundCode, element as ModelElement); } } } catch (Exception ex) { tracer.Error( ex, Properties.Resources.ValidationMethodFailed_Error, Reflector<ArtifactReferenceValidation>.GetMethod(n => n.ValidateArtifactReferences(context, element)).Name); throw; } }
public INodeVisitor Validate(ValidationContext context) { var knownArgs = new Dictionary<string, Argument>(); return new EnterLeaveListener(_ => { _.Match<Field>(field => knownArgs = new Dictionary<string, Argument>()); _.Match<Directive>(field => knownArgs = new Dictionary<string, Argument>()); _.Match<Argument>(argument => { var argName = argument.Name; if (knownArgs.ContainsKey(argName)) { var error = new ValidationError(context.OriginalQuery, "5.3.2", DuplicateArgMessage(argName), knownArgs[argName], argument); context.ReportError(error); } else { knownArgs[argName] = argument; } }); }); }
public PropertyValidatorContext(ValidationContext parentContext, PropertyRule rule, string propertyName, object propertyValue) { ParentContext = parentContext; Rule = rule; PropertyName = propertyName; propertyValueContainer = new Lazy<object>(() => propertyValue); }
public override IEnumerable<ModelValidationResult> Validate(object container) { if (Metadata.Model != null) { var selector = customizations.ToValidatorSelector(); var interceptor = customizations.GetInterceptor() ?? (validator as IValidatorInterceptor); var context = new ValidationContext(Metadata.Model, new PropertyChain(), selector); if(interceptor != null) { // Allow the user to provide a customized context // However, if they return null then just use the original context. context = interceptor.BeforeMvcValidation(ControllerContext, context) ?? context; } var result = validator.Validate(context); if(interceptor != null) { // allow the user to provice a custom collection of failures, which could be empty. // However, if they return null then use the original collection of failures. result = interceptor.AfterMvcValidation(ControllerContext, context, result) ?? result; } if (!result.IsValid) { return ConvertValidationResultToModelValidationResults(result); } } return Enumerable.Empty<ModelValidationResult>(); }
public override IEnumerable<ModelValidationResult> Validate(object container) { // NOTE: Container is never used here, because IValidatableObject doesn't give you // any way to get access to your container. object model = Metadata.ModelValue; if (model == null) { return Enumerable.Empty<ModelValidationResult>(); } var validatable = model as IValidatableObject; if (validatable == null) { throw new InvalidOperationException( String.Format( CultureInfo.CurrentCulture, "ValidatableObjectAdapter_IncompatibleType {0} {1}", typeof(IValidatableObject).FullName, model.GetType().FullName ) ); } var validationContext = new ValidationContext(validatable, null, null); return ConvertResults(validatable.Validate(validationContext)); }
internal void ValidateCustomizedSettingsOverriddenByCustomizableState(ValidationContext context) { try { if (this.IsCustomizationEnabled) { if ((this.IsCustomizable == CustomizationState.False) && (this.Policy.IsModified == true)) { context.LogWarning( string.Format(CultureInfo.CurrentCulture, Properties.Resources.Validate_CustomizedSettingsOverriddenByCustomizableState, this.Name), Properties.Resources.Validate_CustomizedSettingsOverriddenByCustomizableStateCode, this); } } } catch (Exception ex) { tracer.Error( ex, Resources.ValidationMethodFailed_Error, Reflector<CustomizableElementSchemaBase>.GetMethod(n => n.ValidateCustomizedSettingsOverriddenByCustomizableState(context)).Name); throw; } }
public INodeVisitor Validate(ValidationContext context) { var frequency = new Dictionary<string, string>(); return new EnterLeaveListener(_ => { _.Match<Operation>( enter: op => { if (context.Document.Operations.Count < 2) { return; } if (string.IsNullOrWhiteSpace(op.Name)) { return; } if (frequency.ContainsKey(op.Name)) { var error = new ValidationError( context.OriginalQuery, "5.1.1.1", DuplicateOperationNameMessage(op.Name), op); context.ReportError(error); } else { frequency[op.Name] = op.Name; } }); }); }
internal void ValidateNameIsUnique(ValidationContext context) { try { IEnumerable<AutomationSettingsSchema> sameNamedElements = this.Owner.AutomationSettings .Where(setting => setting.Name.Equals(this.Name, System.StringComparison.OrdinalIgnoreCase)); if (sameNamedElements.Count() > 1) { // Check if one of the properties is a system property if (sameNamedElements.FirstOrDefault(property => property.IsSystem == true) != null) { context.LogError( string.Format(CultureInfo.CurrentCulture, Properties.Resources.Validate_AutomationSettingsNameSameAsSystem, this.Name), Properties.Resources.Validate_AutomationSettingsNameSameAsSystemCode, this); } else { context.LogError( string.Format(CultureInfo.CurrentCulture, Properties.Resources.Validate_AutomationSettingsNameIsNotUnique, this.Name), Properties.Resources.Validate_AutomationSettingsNameIsNotUniqueCode, this); } } } catch (Exception ex) { tracer.Error( ex, Resources.ValidationMethodFailed_Error, Reflector<AutomationSettingsSchema>.GetMethod(n => n.ValidateNameIsUnique(context)).Name); throw; } }
public void ValidateClassNames(ValidationContext context, IClass cls) { // Property and Role names must be unique within a class hierarchy. List<string> foundNames = new List<string>(); List<IProperty> allPropertiesInHierarchy = new List<IProperty>(); List<IProperty> superRoles = new List<IProperty>(); FindAllAssocsInSuperClasses(superRoles, cls.SuperClasses); foreach (IProperty p in cls.GetOutgoingAssociationEnds()) { superRoles.Add(p); } foreach (IProperty p in superRoles) { allPropertiesInHierarchy.Add(p); } foreach (IProperty p in cls.Members) { allPropertiesInHierarchy.Add(p); } foreach (IProperty attribute in allPropertiesInHierarchy) { string name = attribute.Name; if (!string.IsNullOrEmpty(name) && foundNames.Contains(name)) { context.LogError( string.Format("Duplicate property or role name '{0}' in class '{1}'", name, cls.Name), "001", cls); } foundNames.Add(name); } }
public INodeVisitor Validate(ValidationContext context) { var variableDefs = new List<VariableDefinition>(); return new EnterLeaveListener(_ => { _.Match<VariableDefinition>(def => variableDefs.Add(def)); _.Match<Operation>( enter: op => variableDefs = new List<VariableDefinition>(), leave: op => { var usages = context.GetRecursiveVariables(op).Select(usage => usage.Node.Name); variableDefs.Apply(variableDef => { var variableName = variableDef.Name; if (!usages.Contains(variableName)) { var error = new ValidationError(context.OriginalQuery, "5.7.5", UnusedVariableMessage(variableName, op.Name), variableDef); context.ReportError(error); } }); }); }); }
private void ValidateManyToManyValidity(ValidationContext context) { ReadOnlyCollection<ManyToManyRelation> manyToManySources = ManyToManyRelation.GetLinksToManyToManySources(this); foreach (ManyToManyRelation relationship in manyToManySources) { if (String.IsNullOrEmpty(relationship.EffectiveTable)) context.LogError( String.Format("Class {0} does not have a table name on it's many to many relation to class {1}", relationship.Source.Name, relationship.Target.Name), "AW001ValidateManyToManyValidity1Error", relationship); if (String.IsNullOrEmpty(relationship.EffectiveSourceColumn)) context.LogError( String.Format("Class {0} does not have a source column name on it's many to many relation to class {1}", relationship.Source.Name, relationship.Target.Name), "AW001ValidateManyToManyValidity2Error", relationship); if (String.IsNullOrEmpty(relationship.EffectiveTargetColumn)) context.LogError( String.Format("Class {0} does not have a target column name on it's many to many relation to class {1}", relationship.Source.Name, relationship.Target.Name), "AW001ValidateManyToManyValidity3Error", relationship); if ((relationship.EffectiveSourceRelationType == RelationType.IdBag || relationship.EffectiveTargetRelationType == RelationType.IdBag) && String.IsNullOrEmpty(relationship.EffectiveCollectionIDColumn)) context.LogError( String.Format("The many to many relationship between {0} and {1} must have a collection id column since it is an IdBag relationship.", relationship.Source.Name, relationship.Target.Name), "AW001ValidateManyToManyValidity4Error", relationship); } }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> IEnumerable <ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { yield break; }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> IEnumerable <System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { yield break; }
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext) { yield break; }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> IEnumerable <System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { foreach (var x in base.BaseValidate(validationContext)) { yield return(x); } // Type (string) pattern Regex regexType = new Regex(@"^StepBooleanInput$", RegexOptions.CultureInvariant); if (false == regexType.Match(this.Type).Success) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for Type, must match a pattern of " + regexType, new [] { "Type" })); } yield break; }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> IEnumerable <System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { foreach (var x in base.BaseValidate(validationContext)) { yield return(x); } yield break; }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> IEnumerable <System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { // DisciplineDescriptor (string) maxLength if (this.DisciplineDescriptor != null && this.DisciplineDescriptor.Length > 306) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for DisciplineDescriptor, length must be less than 306.", new [] { "DisciplineDescriptor" })); } yield break; }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> IEnumerable <System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { // Frequency (string) pattern Regex regexFrequency = new Regex(@"^(EvryDay)$|^(EvryWorkgDay)$|^(IntrvlDay:((0[2-9])|([1-2][0-9])|3[0-1]))$|^(IntrvlWkDay:0[1-9]:0[1-7])$|^(WkInMnthDay:0[1-5]:0[1-7])$|^(IntrvlMnthDay:(0[1-6]|12|24):(-0[1-5]|0[1-9]|[12][0-9]|3[01]))$|^(QtrDay:(ENGLISH|SCOTTISH|RECEIVED))$", RegexOptions.CultureInvariant); if (false == regexFrequency.Match(this.Frequency).Success) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for Frequency, must match a pattern of " + regexFrequency, new [] { "Frequency" })); } // Reference (string) maxLength if (this.Reference != null && this.Reference.Length > 35) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for Reference, length must be less than 35.", new [] { "Reference" })); } // Reference (string) minLength if (this.Reference != null && this.Reference.Length < 1) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for Reference, length must be greater than 1.", new [] { "Reference" })); } // NumberOfPayments (string) maxLength if (this.NumberOfPayments != null && this.NumberOfPayments.Length > 35) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for NumberOfPayments, length must be less than 35.", new [] { "NumberOfPayments" })); } // NumberOfPayments (string) minLength if (this.NumberOfPayments != null && this.NumberOfPayments.Length < 1) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for NumberOfPayments, length must be greater than 1.", new [] { "NumberOfPayments" })); } yield break; }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> protected IEnumerable<System.ComponentModel.DataAnnotations.ValidationResult> BaseValidate(ValidationContext validationContext) { yield break; }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> IEnumerable <System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { // PaymentSolution (string) maxLength if (this.PaymentSolution != null && this.PaymentSolution.Length > 12) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for PaymentSolution, length must be less than 12.", new [] { "PaymentSolution" })); } // CommerceIndicator (string) maxLength if (this.CommerceIndicator != null && this.CommerceIndicator.Length > 20) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for CommerceIndicator, length must be less than 20.", new [] { "CommerceIndicator" })); } yield break; }
private void AddBtn_Click(object sender, EventArgs e) { // information Student st = new Student() { Name = textBox2.Text, SurName = textBox1.Text, MiddleName = textBox3.Text, Specialty = textBox4.Text, Age = (byte)numericUpDown1.Value, Course = (byte)numericUpDown2.Value, Group = (byte)numericUpDown3.Value, }; try { st.AverageScore = (float)Convert.ToDouble(textBox5.Text); } catch { }// MessageBox.Show("Неверное значение среднего балла!", "Проверьте данные!", MessageBoxButtons.OK, MessageBoxIcon.Warning); return; } if (radioButton1.Checked) st.Gender = Gender.М; if (radioButton2.Checked) st.Gender = Gender.Ж; st.Birthday = dateTimePicker1.Value; Address main = new Address(textBox8.Text, textBox9.Text, textBox10.Text, textBox11.Text, (int)numericUpDown5.Value); string validateErrors = ""; var results = new List<ValidationResult>(); var context = new ValidationContext(st); // валидация студента и запись ошибок Validator.TryValidateObject(st, context, results, true); context = new ValidationContext(main); // валидация адреса и запись ошибок Validator.TryValidateObject(main, context, results, true); // переводим ошибки в норм формат foreach (var error in results) { validateErrors += $"{error.ErrorMessage}\n"; } // пол почему-то валидатором не чекается. наверн, из-за того, что это перечисление и имеет стандартное значение // MessageBox.Show(st.Gender.ToString()); // выдает "М"((( if (!radioButton1.Checked && !radioButton2.Checked) validateErrors += "Не установлен пол!"; if (validateErrors.Length != 0) { MessageBox.Show($"Обнаружены ошибки ввода:\n{validateErrors}", "Проверьте данные!", MessageBoxButtons.OK, MessageBoxIcon.Warning); return; } st.MainAddress = main; // дополнительный адрес валидировать не будем st.SecondAddress = new Address(textBox12.Text, textBox13.Text, textBox14.Text, textBox15.Text, (int)numericUpDown6.Value); // work st.Work = new Work(textBox6.Text, textBox7.Text, (int)numericUpDown4.Value); Students.Add(st); studentCount.Text = $"Студентов: {Students.Count}."; }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> IEnumerable <System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { // NumRepeatsAllOnFailed (int?) minimum if (this.NumRepeatsAllOnFailed < (int?)0) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for NumRepeatsAllOnFailed, must be a value greater than or equal to 0.", new [] { "NumRepeatsAllOnFailed" })); } // RepeatsPerUserOnFailed (int?) minimum if (this.RepeatsPerUserOnFailed < (int?)0) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for RepeatsPerUserOnFailed, must be a value greater than or equal to 0.", new [] { "RepeatsPerUserOnFailed" })); } // UserGroupId (int?) minimum if (this.UserGroupId < (int?)0) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for UserGroupId, must be a value greater than or equal to 0.", new [] { "UserGroupId" })); } yield break; }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> IEnumerable<System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { return this.BaseValidate(validationContext); }
public ValidationResult AfterMvcValidation(HttpActionContext cc, ValidationContext context, ValidationResult result) { return new ValidationResult(); }
/// <summary> /// Saves the given post model /// </summary> /// <param name="model">The post model</param> public async Task SaveAsync<T>(T model) where T : PostBase { // Ensure id if (model.Id == Guid.Empty) { model.Id = Guid.NewGuid(); } // Validate model var context = new ValidationContext(model); Validator.ValidateObject(model, context, true); // Ensure title since this field isn't required in // the Content base class if (string.IsNullOrWhiteSpace(model.Title)) { throw new ValidationException("The Title field is required"); } // Ensure type id since this field isn't required in // the Content base class if (string.IsNullOrWhiteSpace(model.TypeId)) { throw new ValidationException("The TypeId field is required"); } // Ensure slug if (string.IsNullOrWhiteSpace(model.Slug)) { model.Slug = Utils.GenerateSlug(model.Title, false); } else { model.Slug = Utils.GenerateSlug(model.Slug, false); } // Call hooks & save App.Hooks.OnBeforeSave<PostBase>(model); await _repo.Save(model).ConfigureAwait(false); App.Hooks.OnAfterSave<PostBase>(model); if (_cache != null) { // Clear all categories from cache in case some // unused where deleted. var categories = await _repo.GetAllCategories(model.BlogId).ConfigureAwait(false); foreach (var category in categories) { _cache.Remove(category.Id.ToString()); _cache.Remove($"Category_{model.BlogId}_{category.Slug}"); } // Clear all tags from cache in case some // unused where deleted. var tags = await _repo.GetAllTags(model.BlogId).ConfigureAwait(false); foreach (var tag in tags) { _cache.Remove(tag.Id.ToString()); _cache.Remove($"Tag_{model.BlogId}_{tag.Slug}"); } } }
public ValidationContext BeforeMvcValidation(HttpActionContext cc, ValidationContext context) { var newContext = context.Clone(selector: new FluentValidation.Internal.MemberNameValidatorSelector(properties)); return newContext; }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> IEnumerable <System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { // CodeBevoegdGezag (string) minLength if (this.CodeBevoegdGezag != null && this.CodeBevoegdGezag.Length < 1) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for CodeBevoegdGezag, length must be greater than 1.", new [] { "CodeBevoegdGezag" })); } // Identificatie (string) minLength if (this.Identificatie != null && this.Identificatie.Length < 1) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for Identificatie, length must be greater than 1.", new [] { "Identificatie" })); } // Opschrift (string) minLength if (this.Opschrift != null && this.Opschrift.Length < 1) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for Opschrift, length must be greater than 1.", new [] { "Opschrift" })); } yield break; }
public ValidationContext BeforeMvcValidation(HttpActionContext controllerContext, ValidationContext validationContext) { return validationContext; }
public ValidationContext BeforeMvcValidation(HttpActionContext cc, ValidationContext context) { return null; }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> IEnumerable <System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { // Name (string) maxLength if (this.Name != null && this.Name.Length > 40) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for Name, length must be less than 40.", new [] { "Name" })); } // Name (string) minLength if (this.Name != null && this.Name.Length < 1) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for Name, length must be greater than 1.", new [] { "Name" })); } yield break; }
public ValidationResult AfterMvcValidation(HttpActionContext controllerContext, ValidationContext validationContext, ValidationResult result) { return new ValidationResult(); //empty errors }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> IEnumerable <System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { foreach (var x in base.BaseValidate(validationContext)) { yield return(x); } // Type (string) pattern Regex regexType = new Regex(@"^AirBoundaryConstructionAbridged$", RegexOptions.CultureInvariant); if (this.Type != null && false == regexType.Match(this.Type).Success) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for Type, must match a pattern of " + regexType, new [] { "Type" })); } // AirMixingPerArea (double) minimum if (this.AirMixingPerArea < (double)0) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for AirMixingPerArea, must be a value greater than or equal to 0.", new [] { "AirMixingPerArea" })); } // AirMixingSchedule (string) maxLength if (this.AirMixingSchedule != null && this.AirMixingSchedule.Length > 100) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for AirMixingSchedule, length must be less than 100.", new [] { "AirMixingSchedule" })); } // AirMixingSchedule (string) minLength if (this.AirMixingSchedule != null && this.AirMixingSchedule.Length < 1) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for AirMixingSchedule, length must be greater than 1.", new [] { "AirMixingSchedule" })); } yield break; }
protected override ValidationResult IsValid(object value, ValidationContext validationContext) { return(base.IsValid(value, validationContext)); }
IValidatableObject.Validate(ValidationContext validationContext) { yield break; }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> IEnumerable <System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { // SettlementMethod (string) maxLength if (this.SettlementMethod != null && this.SettlementMethod.Length > 1) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for SettlementMethod, length must be less than 1.", new [] { "SettlementMethod" })); } // FraudScreeningLevel (string) maxLength if (this.FraudScreeningLevel != null && this.FraudScreeningLevel.Length > 1) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for FraudScreeningLevel, length must be less than 1.", new [] { "FraudScreeningLevel" })); } yield break; }
public virtual IEnumerable<ValidationResult> Validate(ValidationContext validationContext) { // No special validations needed return Enumerable.Empty<ValidationResult>(); }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> IEnumerable <System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { // Name (string) maxLength if (this.Name != null && this.Name.Length > 1024) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for Name, length must be less than 1024.", new [] { "Name" })); } // FileSize (int) maximum if (this.FileSize > (int)2147483647) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for FileSize, must be a value less than or equal to 2147483647.", new [] { "FileSize" })); } // FileSize (int) minimum if (this.FileSize < (int)0) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for FileSize, must be a value greater than or equal to 0.", new [] { "FileSize" })); } // Folder (string) maxLength if (this.Folder != null && this.Folder.Length > 1024) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for Folder, length must be less than 1024.", new [] { "Folder" })); } // Title (string) maxLength if (this.Title != null && this.Title.Length > 1024) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for Title, length must be less than 1024.", new [] { "Title" })); } yield break; }
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext) { throw new NotImplementedException(); }
protected override ValidationResult IsValid(object value, ValidationContext validationContext) { DateTime currentDateTime; if (DateTime.TryParse(value.ToString(), out currentDateTime)) { if (Mode == DateValidatorMode.OverOrEqualToProperty) { DateTime refPropertyDate; Object instance = validationContext.ObjectInstance; Type type = instance.GetType(); Object data = type.GetProperty(this.RefProperty).GetValue(instance, null); if (data != null && data is DateTime) { refPropertyDate = (DateTime)data; } else { return(new ValidationResult("Property reference date is null or not DateTime value")); } if (DateTime.Compare(currentDateTime, refPropertyDate) >= 0) { return(ValidationResult.Success); } else { return(new ValidationResult("Current DateTime is lower than min property")); } } else if (Mode == DateValidatorMode.OverNow) { DateTime minDateTime; if (MinDate.Equals("Now")) { minDateTime = DateTime.Now; } else { DateTime dt; if (!DateTime.TryParse(MinDate, out dt)) { return(new ValidationResult("Cannot parse reference min date to date")); } else { minDateTime = dt; } } if (DateTime.Compare(currentDateTime, minDateTime.Date) >= 0) { return(ValidationResult.Success); } else { return(new ValidationResult("Current DateTime is lower than Now or min DateTime")); } } } else { return(new ValidationResult("Cannot parse to date")); } return(new ValidationResult("Error")); }
public IEnumerable <ValidationResult> Validate(ValidationContext validationContext) { var errors = new List <ValidationResult>(); return(errors); }
/// <summary> /// To validate all properties of the instance /// </summary> /// <param name="validationContext">Validation context</param> /// <returns>Validation Result</returns> IEnumerable <System.ComponentModel.DataAnnotations.ValidationResult> IValidatableObject.Validate(ValidationContext validationContext) { // WalletDivision (int?) maximum if (this.WalletDivision > (int?)7) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for WalletDivision, must be a value less than or equal to 7.", new [] { "WalletDivision" })); } // WalletDivision (int?) minimum if (this.WalletDivision < (int?)1) { yield return(new System.ComponentModel.DataAnnotations.ValidationResult("Invalid value for WalletDivision, must be a value greater than or equal to 1.", new [] { "WalletDivision" })); } yield break; }