Specifies that a data field value is required.
public void RequiredNotThereTest() { RequiredAttribute attribute = new RequiredAttribute(); ValidationErrorCollection errors = new ValidationErrorCollection(); attribute.Validate(requiredNode, valueInfo1, errors); Assert.AreEqual(1, errors.Count); }
public void RequiredNotThereTest() { RequiredAttribute attribute = new RequiredAttribute(); List<ValidationError> errors = new List<ValidationError>(); attribute.Validate(requiredNode, valueInfo1, errors, ServiceProvider); Assert.AreEqual(1, errors.Count); }
public void RequiredValueTest() { RequiredAttribute attribute = new RequiredAttribute(); requiredNode.Value2 = "MyTest"; List<ValidationError> errors = new List<ValidationError>(); attribute.Validate(requiredNode, valueInfo2, errors, ServiceProvider); Assert.AreEqual(0, ValidationAttributeHelper.GetValidationErrorsCount(serviceProvider)); }
public void RequiredValueTest() { RequiredAttribute attribute = new RequiredAttribute(); requiredNode.Value2 = "MyTest"; ValidationErrorCollection errors = new ValidationErrorCollection(); attribute.Validate(requiredNode, valueInfo2, errors); Assert.AreEqual(0, ValidationErrorsCount); }
public static void AllowEmptyStrings_GetSet_ReturnsExpectected() { var attribute = new RequiredAttribute(); Assert.False(attribute.AllowEmptyStrings); attribute.AllowEmptyStrings = true; Assert.True(attribute.AllowEmptyStrings); attribute.AllowEmptyStrings = false; Assert.False(attribute.AllowEmptyStrings); }
public void IsValid_AllowEmptyStrings() { RequiredAttribute attribute = new RequiredAttribute() { AllowEmptyStrings = true }; Assert.IsTrue(attribute.IsValid(String.Empty)); Assert.IsTrue(attribute.IsValid(1)); Assert.IsTrue(attribute.IsValid("abc")); Assert.IsTrue(attribute.IsValid(" ")); Assert.IsTrue(attribute.IsValid("\t")); Assert.IsFalse(attribute.IsValid(null)); }
public void IsValid() { RequiredAttribute required = new RequiredAttribute(); Assert.AreEqual(true, required.IsValid("abcd")); Assert.AreEqual(true, required.IsValid(" ab ")); Assert.AreEqual(true, required.IsValid(10)); Assert.AreEqual(false, required.IsValid("")); Assert.AreEqual(false, required.IsValid(" ")); Assert.AreEqual(false, required.IsValid("\t")); Assert.AreEqual(false, required.IsValid(null)); }
private void CreateComboboxControl(NameAttribute displayNameAttribute, RequiredAttribute requiredAttribute, ConfigEditorAttribute editorTypeAttribute, Binding b) { var dropDownControl = new ConfigComboBoxControl(); dropDownControl.ConfigItemDisplayName = _localController.GetLocalString(displayNameAttribute.LocalType, displayNameAttribute.DisplayName); dropDownControl.SourceList = (ComboBoxList)Activator.CreateInstance(editorTypeAttribute.SourceListType); dropDownControl.SetBinding(ConfigComboBoxControl.SelectedValueProperty, b); dropDownControl.WaterMarkText = requiredAttribute != null ? _localController.GetLocalStrings<SDGuiStrings>().Mandatory : _localController.GetLocalStrings<SDGuiStrings>().Optional; dropDownControl.WaterMarkColor = requiredAttribute != null ? (SolidColorBrush)TryFindResource("Color_FadedRed") : (SolidColorBrush)TryFindResource("Color_FadedGray"); configItemPanel.Children.Add(dropDownControl); }
/// <summary> /// Enregistre les domaines. /// </summary> /// <param name="domainMetadataType">Type de la classe portant les métadonnées des domaines.</param> /// <returns>Liste des domaines créés.</returns> public ICollection <IDomain> RegisterDomainMetadataType(Type domainMetadataType) { if (domainMetadataType == null) { throw new ArgumentNullException("domainMetadataType"); } List <IDomain> list = new List <IDomain>(); foreach (PropertyInfo property in domainMetadataType.GetProperties()) { object[] attrDomainArray = property.GetCustomAttributes(typeof(DomainAttribute), false); if (attrDomainArray.Length > 0) { DomainAttribute domainAttr = (DomainAttribute)attrDomainArray[0]; List <ValidationAttribute> validationAttributes = new List <ValidationAttribute>(); object[] attrValidationArray = property.GetCustomAttributes(typeof(ValidationAttribute), false); foreach (ValidationAttribute validationAttribute in attrValidationArray) { validationAttributes.Add(validationAttribute); RequiredAttribute requiredAttr = validationAttribute as RequiredAttribute; StringLengthAttribute strLenAttr = validationAttribute as StringLengthAttribute; RangeAttribute rangeAttr = validationAttribute as RangeAttribute; if (requiredAttr != null) { requiredAttr.ErrorMessageResourceName = "ConstraintNotNull"; requiredAttr.ErrorMessageResourceType = typeof(SR); } else if (strLenAttr != null) { strLenAttr.ErrorMessageResourceName = "ErrorConstraintStringLength"; strLenAttr.ErrorMessageResourceType = typeof(SR); } else if (rangeAttr != null) { rangeAttr.ErrorMessageResourceName = "ConstraintIntervalBornes"; rangeAttr.ErrorMessageResourceType = typeof(SR); } } TypeConverter formatter = null; object[] attrConverterArray = property.GetCustomAttributes(typeof(CustomTypeConverterAttribute), false); if (attrConverterArray.Length > 0) { CustomTypeConverterAttribute converterAttribute = (CustomTypeConverterAttribute)attrConverterArray[0]; Type converterType = Type.GetType(converterAttribute.ConverterTypeName, false); if (converterType == null) { string simpleTypeName = converterAttribute.ConverterTypeName.Split(',').First(); converterType = domainMetadataType.Assembly.GetType(simpleTypeName); } formatter = (TypeConverter)Activator.CreateInstance(converterType); IFormatter iFormatter = (IFormatter)formatter; if (!string.IsNullOrEmpty(converterAttribute.FormatString)) { iFormatter.FormatString = converterAttribute.FormatString; } if (!string.IsNullOrEmpty(converterAttribute.Unit)) { iFormatter.Unit = converterAttribute.Unit; } } List <Attribute> decorationAttributes = new List <Attribute>(); foreach (object attribute in property.GetCustomAttributes(false)) { if (attribute is DomainAttribute || attribute is TypeConverterAttribute || attribute is ValidationAttribute) { continue; } Attribute extraAttribute = attribute as Attribute; decorationAttributes.Add(extraAttribute); } IDomainChecker domain = (IDomainChecker)Activator.CreateInstance( typeof(Domain <>).MakeGenericType(property.PropertyType), domainAttr.Name, validationAttributes, formatter, decorationAttributes, false, domainAttr.ErrorMessageResourceType, domainAttr.ErrorMessageResourceName, domainAttr.MetadataPropertySuffix); this.RegisterDomain(domain); list.Add(domain); } } return(list); }
protected void HandleRequiredAttribute(TagBuilder tb, RequiredAttribute requiredAttribute) { tb.AddCssClass("required"); tb.MergeAttribute("data-val-required", string.Empty); }
/// <summary> /// 验证必须输入 /// </summary> /// <param name="box">验证框</param> /// <returns></returns> public static ValidBox Required(this ValidBox box) { var newBox = new RequiredAttribute().ToValidBox(); return(ValidBox.Merge(box, newBox)); }
private static string WriteExtenders(PropertyInfo p, out bool isValidatable) { isValidatable = false; StringBuilder sb = new StringBuilder(); sb.Append(".extend({ editState : false, disableValidation : false, empty : true })"); RequiredAttribute requiredAttribute = p.GetCustomAttribute <RequiredAttribute>(); if (requiredAttribute != null) { sb.Append(".extend({ required: { message: \"{0}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{1}\"); } } })".FormatString(requiredAttribute.FormatErrorMessage(p.Name), p.Name)); isValidatable = true; } MinLengthAttribute minLengthAttribute = p.GetCustomAttribute <MinLengthAttribute>(); if (minLengthAttribute != null) { sb.Append(".extend({ minLength: { message: \"{0}\", params: {1}, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })".FormatString(minLengthAttribute.FormatErrorMessage(p.Name), minLengthAttribute.Length, p.Name)); isValidatable = true; } MaxLengthAttribute maxLengthAttribute = p.GetCustomAttribute <MaxLengthAttribute>(); if (maxLengthAttribute != null) { sb.Append(".extend({ maxLength: { message: \"{0}\", params: {1}, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })".FormatString(maxLengthAttribute.FormatErrorMessage(p.Name), maxLengthAttribute.Length, p.Name)); isValidatable = true; } RegularExpressionAttribute regularExpressionAttribute = p.GetCustomAttribute <RegularExpressionAttribute>(); if (regularExpressionAttribute != null) { sb.Append(".extend({ pattern: { message: \"{0}\", params: /{1}/, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })".FormatString(regularExpressionAttribute.FormatErrorMessage(p.Name), regularExpressionAttribute.Pattern, p.Name)); isValidatable = true; } UrlAttribute urlAttribute = p.GetCustomAttribute <UrlAttribute>(); if (urlAttribute != null) { sb.Append(".extend({ pattern: { message: \"{0}\", params: /{1}/, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })".FormatString(urlAttribute.FormatErrorMessage(p.Name), urlAttribute.Regex, p.Name)); isValidatable = true; } DateAttribute dateAttribute = p.GetCustomAttribute <DateAttribute>(); if (dateAttribute != null) { sb.Append(".extend({ date: { message: \"{0}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{1}\"); } } })".FormatString(dateAttribute.FormatErrorMessage(p.Name), p.Name)); isValidatable = true; } NumericAttribute numericAttribute = p.GetCustomAttribute <NumericAttribute>(); if (numericAttribute != null) { sb.Append( ".extend({ number: { message: \"{0}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{1}\"); } } }).extend({ numeric: {2} })".FormatString( numericAttribute.FormatErrorMessage(p.Name), p.Name, numericAttribute.Precision)); isValidatable = true; } EmailAttribute emailAttribute = p.GetCustomAttribute <EmailAttribute>(); if (emailAttribute != null) { sb.Append(".extend({ email: { message: \"{0}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{1}\"); } } })".FormatString(emailAttribute.FormatErrorMessage(p.Name), p.Name)); isValidatable = true; } DigitsAttribute digitsAttribute = p.GetCustomAttribute <DigitsAttribute>(); if (digitsAttribute != null) { sb.Append(".extend({ digit: { message: \"{0}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{1}\"); } } }).extend({ numeric: 0 })".FormatString(digitsAttribute.FormatErrorMessage(p.Name), p.Name)); isValidatable = true; } MinAttribute minAttribute = p.GetCustomAttribute <MinAttribute>(); if (minAttribute != null) { sb.Append(".extend({ min: { message: \"{0}\", params: {1}, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })".FormatString(minAttribute.FormatErrorMessage(p.Name), minAttribute.Min, p.Name)); isValidatable = true; } MaxAttribute maxAttribute = p.GetCustomAttribute <MaxAttribute>(); if (maxAttribute != null) { sb.Append(".extend({ max: { message: \"{0}\", params: {1}, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })".FormatString(maxAttribute.FormatErrorMessage(p.Name), maxAttribute.Max, p.Name)); isValidatable = true; } EqualToAttribute equalToAttribute = p.GetCustomAttribute <EqualToAttribute>(); if (equalToAttribute != null) { sb.Append(".extend({ equal: { message: \"{0}\", params: {1}, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })".FormatString(equalToAttribute.FormatErrorMessage(p.Name), equalToAttribute.OtherProperty, p.Name)); isValidatable = true; } CompareAttribute compareAttribute = p.GetCustomAttribute <CompareAttribute>(); if (compareAttribute != null) { sb.Append(".extend({ equal: { message: \"{0}\", params: \"{1}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })".FormatString(compareAttribute.FormatErrorMessage(p.Name), compareAttribute.OtherProperty, p.Name)); isValidatable = true; } FormatterAttribute formatterAttribute = p.GetCustomAttribute <FormatterAttribute>(); if (formatterAttribute != null) { IJsonSerializer serializer = Container.Get <IJsonSerializer>(); sb.Append(".formatted({0}, {1})".FormatString(formatterAttribute.Formatter, serializer.Serialize(formatterAttribute.Arguments))); } return(sb.ToString()); }
/// <summary> /// Parse metadata given a binding path and entity object. /// </summary> /// <param name="bindingPath">The bindingPath is the name of the property on the entity from which to pull metadata from. This supports dot notation.</param> /// <param name="entity">The entity object from which to pull metadata from.</param> /// <returns>The validation metadata associated with the entity and binding path. This will return null if none exists.</returns> internal static ValidationMetadata ParseMetadata(string bindingPath, object entity) { if (entity != null && !String.IsNullOrEmpty(bindingPath)) { Type entityType = entity.GetType(); PropertyInfo prop = GetProperty(entityType, bindingPath); if (prop != null) { ValidationMetadata newVMD = new ValidationMetadata(); object[] attributes = prop.GetCustomAttributes(false); foreach (object propertyAttribute in attributes) { // Loop through each attribute and update the VMD as appropriate // RequiredField #if NETSTANDARD RequiredAttribute reqAttribute = propertyAttribute as RequiredAttribute; if (reqAttribute != null) { newVMD.IsRequired = true; continue; } #else // BRIDGE Type attrType = propertyAttribute.GetType(); if (attrType.Name == "RequiredAttribute" && attrType.Namespace == "System.ComponentModel.DataAnnotations") { newVMD.IsRequired = true; continue; } #endif // Display attribute parsing #if NETSTANDARD DisplayAttribute displayAttribute = propertyAttribute as DisplayAttribute; if (displayAttribute != null) { newVMD.Description = displayAttribute.GetDescription(); newVMD.Caption = displayAttribute.GetName(); continue; } #else // BRIDGE attrType = propertyAttribute.GetType(); if (attrType.Name == "DisplayAttribute" && attrType.Namespace == "System.ComponentModel.DataAnnotations") { newVMD.Description = (string)attrType.GetMethod("GetDescription", BindingFlags.Public | BindingFlags.Instance) .Invoke(propertyAttribute, new object[0]); newVMD.Caption = (string)attrType.GetMethod("GetName", BindingFlags.Public | BindingFlags.Instance) .Invoke(propertyAttribute, new object[0]); continue; } #endif } if (newVMD.Caption == null) { // If the name is not defined via the DisplayAttribute, use the property name. newVMD.Caption = prop.Name; // Caption can be set to empty string to have an empty Caption and not default // to the property name. } return(newVMD); } } return(null); }
public RequiredAttributeRewriter(RequiredAttribute requiredAttribute) { this.attribute = requiredAttribute; }
public static bool IsRequired(PropertyInfo propertyInfo) { return(RequiredAttribute.IsDefined(propertyInfo, typeof(RequiredAttribute))); }
protected void gvCategories_RowValidating(object sender, ASPxDataValidationEventArgs e) { try { // Checks for null values. foreach (GridViewColumn column in gvCategories.Columns) { if (column is GridViewDataColumn) { GridViewDataColumn dataColumn = column as GridViewDataColumn; if (dataColumn.Visible) { //Validations in model StringLengthAttribute strLenAttr = Utils.GetLengthAttribute(typeof(Category), dataColumn.FieldName); RequiredAttribute requiredAttr = Utils.GetRequiredAttribute(typeof(Category), dataColumn.FieldName); if (requiredAttr != null) { if (e.NewValues[dataColumn.FieldName] == null) { e.Errors[dataColumn] = requiredAttr.ErrorMessage; } else { if (strLenAttr != null) { int maxLen = strLenAttr.MaximumLength; int minLen = strLenAttr.MinimumLength; if (e.NewValues[dataColumn.FieldName].ToString().Length > maxLen || e.NewValues[dataColumn.FieldName].ToString().Length < minLen) { e.Errors[dataColumn] = strLenAttr.ErrorMessage; } } } } } } } // Displays the error row if there is at least one error. if (e.Errors.Count > 0) { if (e.IsNewRow) { e.RowError = "Error al crear el registro"; } else { e.RowError = "Error al actualizar el registro"; } return; } } catch (Exception) { ClientScript.RegisterStartupScript(this.GetType(), "Respuesta", string.Format("alert('{0}');", "Error. Por favor intente más tarde"), true); } //CtrlCategories ctrlCategories = new CtrlCategories(); //List<Category> categoryList = ctrlCategories.GetAllCategories(); //if (e.IsNewRow) //{ // string name = e.NewValues["name"].ToString(); // if (categoryList.FindAll(c => (c.name.ToUpperInvariant().Equals(name.ToUpperInvariant()))).Count > 0) // { // e.RowError = "Error al crear el registro, ya existe una categoría con el mismo Nombre"; // } //} //else //{ // int id = ((Category)((DevExpress.Web.ASPxGridView)sender).GetRow(e.VisibleIndex)).id; // string name = e.NewValues["name"].ToString(); // if (categoryList.FindAll(c => (c.name.ToUpperInvariant().Equals(name.ToUpperInvariant())) && (c.id != id)).Count > 0) // { // e.RowError = "Error al actualizar el registro, ya existe una categoría con el mismo Nombre"; // } //} //if (e.NewValues["ContactName"] != null && // e.NewValues["ContactName"].ToString().Length < 2) //{ // AddError(e.Errors, gvCategories.Columns["ContactName"], // "Contact Name must be at least two characters long."); //} //if (e.NewValues["CompanyName"] != null && //e.NewValues["CompanyName"].ToString().Length < 2) //{ // AddError(e.Errors, gvCategories.Columns["CompanyName"], // "Company Name must be at least two characters long."); //} //if (string.IsNullOrEmpty(e.RowError) && e.Errors.Count > 0) // e.RowError = "Please, correct all errors."; }
private static object[] GetArgs(RequiredAttribute attribute) { return(new object[] { }); }
/// <inheritdoc /> public void CreateValidationMetadata(ValidationMetadataProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } // Read interface .Count once rather than per iteration var contextAttributes = context.Attributes; var contextAttributesCount = contextAttributes.Count; var attributes = new List <object>(contextAttributesCount); for (var i = 0; i < contextAttributesCount; i++) { var attribute = contextAttributes[i]; if (attribute is ValidationProviderAttribute validationProviderAttribute) { attributes.AddRange(validationProviderAttribute.GetValidationAttributes()); } else { attributes.Add(attribute); } } // RequiredAttribute marks a property as required by validation - this means that it // must have a non-null value on the model during validation. var requiredAttribute = attributes.OfType <RequiredAttribute>().FirstOrDefault(); // For non-nullable reference types, treat them as-if they had an implicit [Required]. // This allows the developer to specify [Required] to customize the error message, so // if they already have [Required] then there's no need for us to do this check. if (!_options.SuppressImplicitRequiredAttributeForNonNullableReferenceTypes && requiredAttribute == null && !context.Key.ModelType.IsValueType && context.Key.MetadataKind != ModelMetadataKind.Type) { var addInferredRequiredAttribute = false; if (context.Key.MetadataKind == ModelMetadataKind.Type) { // Do nothing. } else if (context.Key.MetadataKind == ModelMetadataKind.Property) { addInferredRequiredAttribute = IsNullableReferenceType( context.Key.ContainerType, member: null, context.PropertyAttributes); } else if (context.Key.MetadataKind == ModelMetadataKind.Parameter) { addInferredRequiredAttribute = IsNullableReferenceType( context.Key.ParameterInfo?.Member.ReflectedType, context.Key.ParameterInfo.Member, context.ParameterAttributes); } else { throw new InvalidOperationException("Unsupported ModelMetadataKind: " + context.Key.MetadataKind); } if (addInferredRequiredAttribute) { // Since this behavior specifically relates to non-null-ness, we will use the non-default // option to tolerate empty/whitespace strings. empty/whitespace INPUT will still result in // a validation error by default because we convert empty/whitespace strings to null // unless you say otherwise. requiredAttribute = new RequiredAttribute() { AllowEmptyStrings = true, }; attributes.Add(requiredAttribute); } } if (requiredAttribute != null) { context.ValidationMetadata.IsRequired = true; } foreach (var attribute in attributes.OfType <ValidationAttribute>()) { // If another provider has already added this attribute, do not repeat it. // This will prevent attributes like RemoteAttribute (which implement ValidationAttribute and // IClientModelValidator) to be added to the ValidationMetadata twice. // This is to ensure we do not end up with duplication validation rules on the client side. if (!context.ValidationMetadata.ValidatorMetadata.Contains(attribute)) { context.ValidationMetadata.ValidatorMetadata.Add(attribute); } } }
public RequiredAdapter(ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute) : base(metadata, context, attribute) { Attribute.ErrorMessage = Validations.Required; }
public void DefaultErrorMessage() { RequiredAttribute required = new RequiredAttribute(); Assert.AreEqual(String.Format(CultureInfo.CurrentCulture, Resources.DataAnnotationsResources.RequiredAttribute_ValidationError, "SOME_NAME"), required.FormatErrorMessage("SOME_NAME")); }
public WeeeRequiredAttributeAdapter(ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute) : base(metadata, context, attribute) { if (string.IsNullOrEmpty(attribute.ErrorMessage) && !string.IsNullOrEmpty(metadata.DisplayName)) { attribute.ErrorMessage = string.Format("Enter {0}", metadata.DisplayName.ToLower()); } }
private static TagBuilder TextBoxTagFor <TModel, TValue>(this HtmlHelper <TModel> html, Expression <Func <TModel, TValue> > expression, bool readOnly = false, bool required = false) { TagBuilder tag = null; ModelMetadata meta = ModelMetadata.FromLambdaExpression(expression, html.ViewData); MemberExpression body = expression.Body as MemberExpression; if (body != null) { RequiredAttribute requiredAttribute = (body.Member.GetCustomAttributes(typeof(RequiredAttribute), false)).FirstOrDefault() as RequiredAttribute; required = required || requiredAttribute != null; var value = GetModelValue(meta); tag = TextBoxTag(html, meta.DisplayName, meta.PropertyName, meta.PropertyName, new ViewModels.FieldProperties { ReadOnly = readOnly, Required = required, Value = value }); MaxLengthAttribute maxLengthAttribute = (body.Member.GetCustomAttributes(typeof(MaxLengthAttribute), false)).FirstOrDefault() as MaxLengthAttribute; if (maxLengthAttribute != null) { tag.Attributes.Add("data-rule-maxlength", maxLengthAttribute.Length.ToString()); } MinLengthAttribute minLengthAttribute = (body.Member.GetCustomAttributes(typeof(MinLengthAttribute), false)).FirstOrDefault() as MinLengthAttribute; if (minLengthAttribute != null) { tag.Attributes.Add("data-rule-minlength", minLengthAttribute.Length.ToString()); } RangeAttribute rangeAttribute = (body.Member.GetCustomAttributes(typeof(RangeAttribute), false)).FirstOrDefault() as RangeAttribute; if (rangeAttribute != null) { tag.Attributes.Add("data-rule-range", "[" + rangeAttribute.Minimum + "," + rangeAttribute.Maximum + "]"); } EmailAddressAttribute email = (body.Member.GetCustomAttributes(typeof(EmailAddressAttribute), false)).FirstOrDefault() as EmailAddressAttribute; if (email != null) { tag.Attributes.Add("data-rule-email", "true"); } UrlAttribute url = (body.Member.GetCustomAttributes(typeof(UrlAttribute), false)).FirstOrDefault() as UrlAttribute; if (url != null) { tag.Attributes.Add("data-rule-url", "true"); } System.ComponentModel.DataAnnotations.CompareAttribute compare = (body.Member.GetCustomAttributes(typeof(System.ComponentModel.DataAnnotations.CompareAttribute), false)) .FirstOrDefault() as System.ComponentModel.DataAnnotations.CompareAttribute; if (compare != null) { tag.Attributes.Add("data-rule-equalTo", "#" + compare.OtherProperty.ToLower()); } var type = meta.ModelType; if (type == typeof(int) || type == typeof(float) || type == typeof(long) || type == typeof(byte) || type == typeof(short) || type == typeof(decimal) || type == typeof(double) || type == typeof(int?) || type == typeof(float?) || type == typeof(long?) || type == typeof(byte?) || type == typeof(short?) || type == typeof(decimal?) || type == typeof(double?)) { if (!tag.Attributes.ContainsKey("value")) { tag.Attributes.Add("value", ""); } tag.Attributes.Add("data-rule-number", "true"); } } return(tag); }
/// <summary> /// Initializes a new instance of the <see cref="InfrastructureRequiredAttributeAdapter" /> class. /// </summary> /// <param name="metadata">The model metadata.</param> /// <param name="context">The controller context.</param> /// <param name="attribute">The attribute.</param> public InfrastructureRequiredAttributeAdapter(ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute) : base(metadata, context, attribute) { }
public TypePropertyMetadata(PropertyDescriptor descriptor) { Name = descriptor.Name; Type elementType = TypeUtility.GetElementType(descriptor.PropertyType); IsArray = !elementType.Equals(descriptor.PropertyType); // TODO: What should we do with nullable types here? TypeName = elementType.Name; TypeNamespace = elementType.Namespace; AttributeCollection propertyAttributes = TypeDescriptorExtensions.ExplicitAttributes(descriptor); // TODO, 336102, ReadOnlyAttribute for editability? RIA used EditableAttribute? ReadOnlyAttribute readonlyAttr = (ReadOnlyAttribute)propertyAttributes[typeof(ReadOnlyAttribute)]; IsReadOnly = (readonlyAttr != null) ? readonlyAttr.IsReadOnly : false; AssociationAttribute associationAttr = (AssociationAttribute)propertyAttributes[typeof(AssociationAttribute)]; if (associationAttr != null) { Association = new TypePropertyAssociationMetadata(associationAttr); } RequiredAttribute requiredAttribute = (RequiredAttribute)propertyAttributes[typeof(RequiredAttribute)]; if (requiredAttribute != null) { _validationRules.Add(new TypePropertyValidationRuleMetadata(requiredAttribute)); } RangeAttribute rangeAttribute = (RangeAttribute)propertyAttributes[typeof(RangeAttribute)]; if (rangeAttribute != null) { Type operandType = rangeAttribute.OperandType; operandType = Nullable.GetUnderlyingType(operandType) ?? operandType; if (operandType.Equals(typeof(Double)) || operandType.Equals(typeof(Int16)) || operandType.Equals(typeof(Int32)) || operandType.Equals(typeof(Int64)) || operandType.Equals(typeof(Single))) { _validationRules.Add(new TypePropertyValidationRuleMetadata(rangeAttribute)); } } StringLengthAttribute stringLengthAttribute = (StringLengthAttribute)propertyAttributes[typeof(StringLengthAttribute)]; if (stringLengthAttribute != null) { _validationRules.Add(new TypePropertyValidationRuleMetadata(stringLengthAttribute)); } DataTypeAttribute dataTypeAttribute = (DataTypeAttribute)propertyAttributes[typeof(DataTypeAttribute)]; if (dataTypeAttribute != null) { if (dataTypeAttribute.DataType.Equals(DataType.EmailAddress) || dataTypeAttribute.DataType.Equals(DataType.Url)) { _validationRules.Add(new TypePropertyValidationRuleMetadata(dataTypeAttribute)); } } }
protected void gvProducts_RowValidating(object sender, ASPxDataValidationEventArgs e) { try { // Checks for null values. foreach (GridViewColumn column in gvProducts.Columns) { if (column is GridViewDataColumn) { GridViewDataColumn dataColumn = column as GridViewDataColumn; if (dataColumn.Visible) { //In editMode is not valid to change the ProductType if ((dataColumn.FieldName.ToUpper() == "productTypeId".ToUpper()) && (!e.IsNewRow)) { continue; } //Validations in model StringLengthAttribute strLenAttr = Utils.GetLengthAttribute(typeof(Product), dataColumn.FieldName); RequiredAttribute requiredAttr = Utils.GetRequiredAttribute(typeof(Product), dataColumn.FieldName); bool isNewRow = e.IsNewRow; if (requiredAttr != null) { if (e.NewValues[dataColumn.FieldName] == null) { e.Errors[dataColumn] = requiredAttr.ErrorMessage; } else { if (strLenAttr != null) { int maxLen = strLenAttr.MaximumLength; int minLen = strLenAttr.MinimumLength; if (e.NewValues[dataColumn.FieldName].ToString().Length > maxLen || e.NewValues[dataColumn.FieldName].ToString().Length < minLen) { e.Errors[dataColumn] = strLenAttr.ErrorMessage; } } } } } } } // Displays the error row if there is at least one error. if (e.Errors.Count > 0) { if (e.IsNewRow) { e.RowError = "Error al crear el registro"; } else { e.RowError = "Error al actualizar el registro"; } return; } } catch (Exception) { ClientScript.RegisterStartupScript(this.GetType(), "Respuesta", string.Format("alert('{0}');", "Error. Por favor intente más tarde"), true); } }
public RequiredIfAttribute(string dependentProperty, object targetValue) { _innerAttribute = new RequiredAttribute(); DependentProperty = dependentProperty; TargetValue = targetValue; }
/// <inheritdoc /> public void CreateValidationMetadata(ValidationMetadataProviderContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } // Read interface .Count once rather than per iteration var contextAttributes = context.Attributes; var contextAttributesCount = contextAttributes.Count; var attributes = new List <object>(contextAttributesCount); for (var i = 0; i < contextAttributesCount; i++) { var attribute = contextAttributes[i]; if (attribute is ValidationProviderAttribute validationProviderAttribute) { attributes.AddRange(validationProviderAttribute.GetValidationAttributes()); } else { attributes.Add(attribute); } } // RequiredAttribute marks a property as required by validation - this means that it // must have a non-null value on the model during validation. var requiredAttribute = attributes.OfType <RequiredAttribute>().FirstOrDefault(); // For non-nullable reference types, treat them as-if they had an implicit [Required]. // This allows the developer to specify [Required] to customize the error message, so // if they already have [Required] then there's no need for us to do this check. if (!_options.SuppressImplicitRequiredAttributeForNonNullableReferenceTypes && requiredAttribute == null && !context.Key.ModelType.IsValueType && context.Key.MetadataKind != ModelMetadataKind.Type) { var addInferredRequiredAttribute = false; if (context.Key.MetadataKind == ModelMetadataKind.Type) { // Do nothing. } else if (context.Key.MetadataKind == ModelMetadataKind.Property) { var property = context.Key.PropertyInfo; if (property is null) { // PropertyInfo was unavailable on ModelIdentity prior to 3.1. // Making a cogent argument about the nullability of the property requires inspecting the declared type, // since looking at the runtime type may result in false positives: https://github.com/dotnet/aspnetcore/issues/14812 // The only way we could arrive here is if the ModelMetadata was constructed using the non-default provider. // We'll cursorily examine the attributes on the property, but not the ContainerType to make a decision about it's nullability. if (HasNullableAttribute(context.PropertyAttributes !, out var propertyHasNullableAttribute)) { addInferredRequiredAttribute = propertyHasNullableAttribute; } } else { addInferredRequiredAttribute = IsNullableReferenceType( property.DeclaringType !, member: null, context.PropertyAttributes !); } } else if (context.Key.MetadataKind == ModelMetadataKind.Parameter) { // If the default value is assigned we don't need to check the nullabilty // since the parameter will be optional. if (!context.Key.ParameterInfo !.HasDefaultValue) { addInferredRequiredAttribute = IsNullableReferenceType( context.Key.ParameterInfo !.Member.ReflectedType, context.Key.ParameterInfo.Member, context.ParameterAttributes !); } } else { throw new InvalidOperationException("Unsupported ModelMetadataKind: " + context.Key.MetadataKind); } if (addInferredRequiredAttribute) { // Since this behavior specifically relates to non-null-ness, we will use the non-default // option to tolerate empty/whitespace strings. empty/whitespace INPUT will still result in // a validation error by default because we convert empty/whitespace strings to null // unless you say otherwise. requiredAttribute = new RequiredAttribute() { AllowEmptyStrings = true, }; attributes.Add(requiredAttribute); } } if (requiredAttribute != null) { context.ValidationMetadata.IsRequired = true; } foreach (var attribute in attributes.OfType <ValidationAttribute>()) { // If another provider has already added this attribute, do not repeat it. // This will prevent attributes like RemoteAttribute (which implement ValidationAttribute and // IClientModelValidator) to be added to the ValidationMetadata twice. // This is to ensure we do not end up with duplication validation rules on the client side. if (!context.ValidationMetadata.ValidatorMetadata.Contains(attribute)) { context.ValidationMetadata.ValidatorMetadata.Add(attribute); } } }
public void CheckNothingRequired() { var tag = new Scope(); RequiredAttribute.Check(tag); }
protected override ModelMetadata CreateMetadata(IEnumerable <Attribute> attributes, Type containerType, Func <object> modelAccessor, Type modelType, string propertyName) { List <Attribute> attributeList = new List <Attribute>(attributes); DisplayColumnAttribute displayColumnAttribute = attributeList.OfType <DisplayColumnAttribute>().FirstOrDefault(); DataAnnotationsModelMetadata result = new DataAnnotationsModelMetadata(this, containerType, modelAccessor, modelType, propertyName, displayColumnAttribute); // Do [HiddenInput] before [UIHint], so you can override the template hint HiddenInputAttribute hiddenInputAttribute = attributeList.OfType <HiddenInputAttribute>().FirstOrDefault(); if (hiddenInputAttribute != null) { result.TemplateHint = "HiddenInput"; result.HideSurroundingHtml = !hiddenInputAttribute.DisplayValue; } // We prefer [UIHint("...", PresentationLayer = "MVC")] but will fall back to [UIHint("...")] IEnumerable <UIHintAttribute> uiHintAttributes = attributeList.OfType <UIHintAttribute>(); UIHintAttribute uiHintAttribute = uiHintAttributes.FirstOrDefault(a => String.Equals(a.PresentationLayer, "MVC", StringComparison.OrdinalIgnoreCase)) ?? uiHintAttributes.FirstOrDefault(a => String.IsNullOrEmpty(a.PresentationLayer)); if (uiHintAttribute != null) { result.TemplateHint = uiHintAttribute.UIHint; } DataTypeAttribute dataTypeAttribute = attributeList.OfType <DataTypeAttribute>().FirstOrDefault(); if (dataTypeAttribute != null) { result.DataTypeName = dataTypeAttribute.ToDataTypeName(); } EditableAttribute editable = attributes.OfType <EditableAttribute>().FirstOrDefault(); if (editable != null) { result.IsReadOnly = !editable.AllowEdit; } else { ReadOnlyAttribute readOnlyAttribute = attributeList.OfType <ReadOnlyAttribute>().FirstOrDefault(); if (readOnlyAttribute != null) { result.IsReadOnly = readOnlyAttribute.IsReadOnly; } } DisplayFormatAttribute displayFormatAttribute = attributeList.OfType <DisplayFormatAttribute>().FirstOrDefault(); if (displayFormatAttribute == null && dataTypeAttribute != null) { displayFormatAttribute = dataTypeAttribute.DisplayFormat; } if (displayFormatAttribute != null) { result.NullDisplayText = displayFormatAttribute.NullDisplayText; result.DisplayFormatString = displayFormatAttribute.DataFormatString; result.ConvertEmptyStringToNull = displayFormatAttribute.ConvertEmptyStringToNull; if (displayFormatAttribute.ApplyFormatInEditMode) { result.EditFormatString = displayFormatAttribute.DataFormatString; } if (!displayFormatAttribute.HtmlEncode && String.IsNullOrWhiteSpace(result.DataTypeName)) { result.DataTypeName = DataTypeUtil.HtmlTypeName; } } ScaffoldColumnAttribute scaffoldColumnAttribute = attributeList.OfType <ScaffoldColumnAttribute>().FirstOrDefault(); if (scaffoldColumnAttribute != null) { result.ShowForDisplay = result.ShowForEdit = scaffoldColumnAttribute.Scaffold; } DisplayAttribute display = attributes.OfType <DisplayAttribute>().FirstOrDefault(); string name = null; if (display != null) { result.Description = display.GetDescription(); result.ShortDisplayName = display.GetShortName(); result.Watermark = display.GetPrompt(); result.Order = display.GetOrder() ?? ModelMetadata.DefaultOrder; name = display.GetName(); } if (name != null) { result.DisplayName = name; } else { DisplayNameAttribute displayNameAttribute = attributeList.OfType <DisplayNameAttribute>().FirstOrDefault(); if (displayNameAttribute != null) { result.DisplayName = displayNameAttribute.DisplayName; } } RequiredAttribute requiredAttribute = attributeList.OfType <RequiredAttribute>().FirstOrDefault(); if (requiredAttribute != null) { result.IsRequired = true; } return(result); }
private Control GetControl(PropertyInfo pi) { object[] attributes = pi.GetCustomAttributes(true); Control _Controls = new Control(); //finding out control attribue int ControlAttributesCount = (from a in attributes where a.GetType().BaseType == typeof(ControlAttribute) || a.GetType().BaseType.BaseType == typeof(ControlAttribute) select a).Count(); if (ControlAttributesCount == 0) { //adding default attributes ArrayList defaultAttributes = new ArrayList(attributes); TextBoxAttribute textbox = new TextBoxAttribute(); defaultAttributes.Add(textbox); string controlName = pi.Name; //String.Format("{0}_TextBoxAttribute", pi.Name); RequiredAttribute vrAtt = new RequiredAttribute(); defaultAttributes.Add(vrAtt); switch (pi.PropertyType.Name) { case "Int32": RegExpAttribute veAtt = new RegExpAttribute(); veAtt.ValidationExpression = @"\d"; defaultAttributes.Add(veAtt); break; case "String": break; default: break; } attributes = defaultAttributes.ToArray(); } foreach (Attribute att in attributes) { //checking validation bool isValidation = false; if (att.GetType().BaseType == typeof(ValidationAttribute)) isValidation = true; /* Begin Validation Controls Geneation */ if (isValidation) { //General Validator Control string ControlType = att.GetType().GetProperty("ControlType").GetValue(att, null).ToString(); Control ValidationControl = (Control)System.Activator.CreateInstance(Type.GetType(ControlType)); //binding BindAttributeFieldsToProperties(ValidationControl, att); if (att.GetType() == typeof(CustomValidatorAttribute)) { string ServerValidationEventName = GetFieldValue(att, "ServerValidationEventName").ToString(); ValidationControl.GetType().GetEvent(ServerValidationEventName).AddEventHandler(ValidationControl, new ServerValidateEventHandler(ServerValidation)); } //Assigning ControlToValidate Property with the propertyName string ControlToValidatePropertyName = GetFieldValue(att, "ControlToValidatePropertyName").ToString(); ValidationControl.GetType().GetProperty(ControlToValidatePropertyName).SetValue(ValidationControl, pi.Name, null); //firing the event OnValidationCreated(ValidationControl, new FieldEventArgs(pi.Name, pi.PropertyType)); _Controls.Controls.Add(ValidationControl); } /* Finish Validation Controls Geneation */ else { // generic control PropertyInfo typePropertyInfo = att.GetType().GetProperty("ControlTypeName"); if (typePropertyInfo != null) { string typeName = typePropertyInfo.GetValue(att, null).ToString(); Control control = (Control)System.Activator.CreateInstance(Type.GetType(typeName)); control.ID = pi.Name;//+ "_" + att.GetType().Name; //binding fields BindAttributeFieldsToProperties(control, att); string bindingPropertyName = att.GetType().GetProperty("BindingProperty").GetValue(att, null).ToString(); PropertyInfo controlBindingProperty = control.GetType().GetProperty(bindingPropertyName); //DataControls bool isDataControl = (bool)att.GetType().GetField("IsDataControl").GetValue(att); if (isDataControl) { bool AutoPostBack = (bool)control.GetType().GetProperty("AutoPostBack").GetValue(control, null); if (AutoPostBack) { string IndexChangeEventName = att.GetType().GetField("IndexChangeEventName").GetValue(att).ToString(); control.GetType().GetEvent(IndexChangeEventName).AddEventHandler(control, new EventHandler(LookupPostback)); } //firing event OnLookupControlCreated(control, new FieldEventArgs(pi.Name, pi.PropertyType)); //seting select value after event if (Mode == Opertion.update) controlBindingProperty.SetValue(control, Convert.ChangeType(pi.GetValue(DataSource, null), control.GetType().GetProperty(bindingPropertyName).PropertyType), null); _Controls.Controls.Add(control); } else { //DirectBinding Property controlBindingProperty.SetValue(control, Convert.ChangeType(pi.GetValue(DataSource, null), control.GetType().GetProperty(bindingPropertyName).PropertyType), null); //firing the event OnControlCreated(control, new FieldEventArgs(pi.Name, pi.PropertyType)); _Controls.Controls.Add(control); } } } } return _Controls; }
private static JqGridColumnModel SetEditOptions(JqGridColumnModel columnModel, IUrlHelper urlHelper, Type modelType, JqGridColumnEditableAttribute jqGridColumnEditableAttribute, RangeAttribute rangeAttribute, RequiredAttribute requiredAttribute) { if (jqGridColumnEditableAttribute != null) { columnModel.DateFormat = jqGridColumnEditableAttribute.DateFormat; columnModel.Editable = jqGridColumnEditableAttribute.Editable; columnModel.EditOptions = GetElementOptions(jqGridColumnEditableAttribute.EditOptions, urlHelper, jqGridColumnEditableAttribute); columnModel.EditOptions.PostData = jqGridColumnEditableAttribute.PostData; columnModel.EditRules = GetRules(modelType, jqGridColumnEditableAttribute, rangeAttribute, requiredAttribute); columnModel.EditType = jqGridColumnEditableAttribute.EditType; columnModel.FormOptions = jqGridColumnEditableAttribute.FormOptions; } return(columnModel); }
private static void ApplyRequiredAttribute(OpenApiSchema schema, RequiredAttribute requiredAttribute) { schema.Nullable = false; }
private static JqGridColumnRules GetRules(Type modelType, JqGridColumnElementAttribute jqGridColumnElementAttribute, RangeAttribute rangeAttribute, RequiredAttribute requiredAttribute) { JqGridColumnRules rules = jqGridColumnElementAttribute.Rules; if (rules != null) { if (requiredAttribute != null) { rules.Required = true; } if (rangeAttribute != null) { rules.MaxValue = Convert.ToDouble(rangeAttribute.Maximum); rules.MinValue = Convert.ToDouble(rangeAttribute.Minimum); } if ((modelType == typeof(Int16)) || (modelType == typeof(Int32)) || (modelType == typeof(Int64)) || (modelType == typeof(UInt16)) || (modelType == typeof(UInt32)) || (modelType == typeof(UInt32))) { rules.Integer = true; } else if ((modelType == typeof(Decimal)) || (modelType == typeof(Double)) || (modelType == typeof(Single))) { rules.Number = true; } } return(rules); }
private void CreateTextboxControl(NameAttribute displayNameAttribute, RequiredAttribute requiredAttribute, Binding b) { var textItemControl = new ConfigTextControl(); textItemControl.ConfigItemDisplayName = _localController.GetLocalString(displayNameAttribute.LocalType, displayNameAttribute.DisplayName); textItemControl.SetBinding(ConfigTextControl.ConfigItemValueProperty, b); textItemControl.WaterMarkText = requiredAttribute != null ? _localController.GetLocalStrings<SDGuiStrings>().Mandatory : _localController.GetLocalStrings<SDGuiStrings>().Optional; textItemControl.WaterMarkColor = requiredAttribute != null ? (SolidColorBrush)TryFindResource("Color_FadedRed") : (SolidColorBrush)TryFindResource("Color_FadedGray"); configItemPanel.Children.Add(textItemControl); }
private static IMandatoryFacet Create(RequiredAttribute attribute, ISpecification holder) => attribute != null ? new MandatoryFacet(holder) : null;
private void CreateFilesystemControl(NameAttribute displayNameAttribute, RequiredAttribute requiredAttribute, ConfigEditorAttribute editorTypeAttribute, Binding b) { var fileSystemControl = new ConfigFileSystemControl(); fileSystemControl.ConfigItemDisplayName = _localController.GetLocalString(displayNameAttribute.LocalType, displayNameAttribute.DisplayName); fileSystemControl.SetBinding(ConfigFileSystemControl.ConfigItemValueProperty, b); fileSystemControl.WaterMarkText = requiredAttribute != null ? _localController.GetLocalStrings<SDGuiStrings>().Mandatory : _localController.GetLocalStrings<SDGuiStrings>().Optional; fileSystemControl.WaterMarkColor = requiredAttribute != null ? (SolidColorBrush)TryFindResource("Color_FadedRed") : (SolidColorBrush)TryFindResource("Color_FadedGray"); fileSystemControl.IsFileSelector = editorTypeAttribute.Editor == EditorType.Filepicker; fileSystemControl.OpenFileFilter = editorTypeAttribute.OpenFileFilter; configItemPanel.Children.Add(fileSystemControl); }
public RequiredValidator(ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute) : base(metadata, context, attribute) { }
/// <summary> /// Loads all content from a folder hierarchy (overlaying anything already existing) /// </summary> /// <param name="project"></param> /// <param name="path"></param> public static void Load(DocProject project, string path) { // get all files within folder hierarchy string pathSchema = path + @"\schemas"; IEnumerable <string> en = System.IO.Directory.EnumerateFiles(pathSchema, "*.cs", System.IO.SearchOption.AllDirectories); List <string> list = new List <string>(); foreach (string s in en) { list.Add(s); } string[] files = list.ToArray(); Dictionary <string, string> options = new Dictionary <string, string> { { "CompilerVersion", "v4.0" } }; Microsoft.CSharp.CSharpCodeProvider prov = new Microsoft.CSharp.CSharpCodeProvider(options); System.CodeDom.Compiler.CompilerParameters parms = new System.CodeDom.Compiler.CompilerParameters(); parms.GenerateInMemory = true; parms.GenerateExecutable = false; parms.ReferencedAssemblies.Add("System.dll"); parms.ReferencedAssemblies.Add("System.Core.dll"); parms.ReferencedAssemblies.Add("System.ComponentModel.dll"); parms.ReferencedAssemblies.Add("System.ComponentModel.DataAnnotations.dll"); parms.ReferencedAssemblies.Add("System.Data.dll"); parms.ReferencedAssemblies.Add("System.Runtime.Serialization.dll"); parms.ReferencedAssemblies.Add("System.Xml.dll"); System.CodeDom.Compiler.CompilerResults results = prov.CompileAssemblyFromFile(parms, files); System.Reflection.Assembly assem = results.CompiledAssembly; // look through classes of assembly foreach (Type t in assem.GetTypes()) { string[] namespaceparts = t.Namespace.Split('.'); string schema = namespaceparts[namespaceparts.Length - 1]; DocSection docSection = null; if (t.Namespace.EndsWith("Resource")) { docSection = project.Sections[7]; } else if (t.Namespace.EndsWith("Domain")) { docSection = project.Sections[6]; } else if (t.Namespace.Contains("Shared")) { docSection = project.Sections[5]; } else { docSection = project.Sections[4]; // kernel, extensions } // find schema DocSchema docSchema = null; foreach (DocSchema docEachSchema in docSection.Schemas) { if (docEachSchema.Name.Equals(schema)) { docSchema = docEachSchema; break; } } if (docSchema == null) { docSchema = new DocSchema(); docSchema.Name = schema; docSection.Schemas.Add(docSchema); docSection.SortSchemas(); } DocDefinition docDef = null; if (t.IsEnum) { DocEnumeration docEnum = new DocEnumeration(); docSchema.Types.Add(docEnum); docDef = docEnum; System.Reflection.FieldInfo[] fields = t.GetFields(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public); foreach (System.Reflection.FieldInfo field in fields) { DocConstant docConst = new DocConstant(); docEnum.Constants.Add(docConst); docConst.Name = field.Name; DescriptionAttribute[] attrs = (DescriptionAttribute[])field.GetCustomAttributes(typeof(DescriptionAttribute), false); if (attrs.Length == 1) { docConst.Documentation = attrs[0].Description; } } } else if (t.IsValueType) { DocDefined docDefined = new DocDefined(); docSchema.Types.Add(docDefined); docDef = docDefined; PropertyInfo[] fields = t.GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public); docDefined.DefinedType = fields[0].PropertyType.Name; } else if (t.IsInterface) { DocSelect docSelect = new DocSelect(); docSchema.Types.Add(docSelect); docDef = docSelect; } else if (t.IsClass) { DocEntity docEntity = new DocEntity(); docSchema.Entities.Add(docEntity); docDef = docEntity; if (t.BaseType != typeof(object)) { docEntity.BaseDefinition = t.BaseType.Name; } if (!t.IsAbstract) { docEntity.EntityFlags = 0x20; } Dictionary <int, DocAttribute> attrsDirect = new Dictionary <int, DocAttribute>(); List <DocAttribute> attrsInverse = new List <DocAttribute>(); PropertyInfo[] fields = t.GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.NonPublic | BindingFlags.DeclaredOnly); foreach (PropertyInfo field in fields) { DocAttribute docAttr = new DocAttribute(); docAttr.Name = field.Name.Substring(1); Type typeField = field.PropertyType; if (typeField.IsGenericType) { Type typeGeneric = typeField.GetGenericTypeDefinition(); typeField = typeField.GetGenericArguments()[0]; if (typeGeneric == typeof(Nullable <>)) { docAttr.IsOptional = true; } else if (typeGeneric == typeof(ISet <>)) { docAttr.AggregationType = (int)DocAggregationEnum.SET; } else if (typeGeneric == typeof(IList <>)) { docAttr.AggregationType = (int)DocAggregationEnum.LIST; } } docAttr.DefinedType = typeField.Name; MinLengthAttribute mla = (MinLengthAttribute)field.GetCustomAttribute(typeof(MinLengthAttribute)); if (mla != null) { docAttr.AggregationLower = mla.Length.ToString(); } MaxLengthAttribute mxa = (MaxLengthAttribute)field.GetCustomAttribute(typeof(MaxLengthAttribute)); if (mxa != null) { docAttr.AggregationUpper = mxa.Length.ToString(); } PropertyInfo propinfo = t.GetProperty(docAttr.Name); if (propinfo != null) { DescriptionAttribute da = (DescriptionAttribute)propinfo.GetCustomAttribute(typeof(DescriptionAttribute)); if (da != null) { docAttr.Documentation = da.Description; } } DataMemberAttribute dma = (DataMemberAttribute)field.GetCustomAttribute(typeof(DataMemberAttribute)); if (dma != null) { attrsDirect.Add(dma.Order, docAttr); RequiredAttribute rqa = (RequiredAttribute)field.GetCustomAttribute(typeof(RequiredAttribute)); if (rqa == null) { docAttr.IsOptional = true; } CustomValidationAttribute cva = (CustomValidationAttribute)field.GetCustomAttribute(typeof(CustomValidationAttribute)); if (cva != null) { docAttr.IsUnique = true; } } else { InversePropertyAttribute ipa = (InversePropertyAttribute)field.GetCustomAttribute(typeof(InversePropertyAttribute)); if (ipa != null) { docAttr.Inverse = ipa.Property; attrsInverse.Add(docAttr); } } // xml XmlIgnoreAttribute xia = (XmlIgnoreAttribute)field.GetCustomAttribute(typeof(XmlIgnoreAttribute)); if (xia != null) { docAttr.XsdFormat = DocXsdFormatEnum.Hidden; } else { XmlElementAttribute xea = (XmlElementAttribute)field.GetCustomAttribute(typeof(XmlElementAttribute)); if (xea != null) { if (!String.IsNullOrEmpty(xea.ElementName)) { docAttr.XsdFormat = DocXsdFormatEnum.Element; } else { docAttr.XsdFormat = DocXsdFormatEnum.Attribute; } } } } foreach (DocAttribute docAttr in attrsDirect.Values) { docEntity.Attributes.Add(docAttr); } foreach (DocAttribute docAttr in attrsInverse) { docEntity.Attributes.Add(docAttr); } // get derived attributes based on properties PropertyInfo[] props = t.GetProperties(BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.Public); foreach (PropertyInfo prop in props) { // if no backing field, then derived FieldInfo field = t.GetField("_" + prop.Name, BindingFlags.NonPublic | BindingFlags.Instance); if (field == null) { DocAttribute docDerived = new DocAttribute(); docDerived.Name = prop.Name; docEntity.Attributes.Add(docDerived); } } } if (docDef != null) { docDef.Name = t.Name; docDef.Uuid = t.GUID; } docSchema.SortTypes(); docSchema.SortEntities(); } // pass 2: hook up selects foreach (Type t in assem.GetTypes()) { Type[] typeInterfaces = t.GetInterfaces(); if (typeInterfaces.Length > 0) { foreach (Type typeI in typeInterfaces) { DocSelect docSelect = project.GetDefinition(typeI.Name) as DocSelect; if (docSelect != null) { DocSelectItem docItem = new DocSelectItem(); docItem.Name = t.Name; docSelect.Selects.Add(docItem); } } } } // EXPRESS rules (eventually in C#, though .exp file snippets for now) en = System.IO.Directory.EnumerateFiles(pathSchema, "*.exp", System.IO.SearchOption.AllDirectories); foreach (string file in en) { string name = Path.GetFileNameWithoutExtension(file); string expr = null; using (StreamReader readExpr = new StreamReader(file, Encoding.UTF8)) { expr = readExpr.ReadToEnd(); } if (name.Contains('-')) { // where rule string[] parts = name.Split('-'); if (parts.Length == 2) { DocWhereRule docWhere = new DocWhereRule(); docWhere.Name = parts[1]; docWhere.Expression = expr; DocDefinition docDef = project.GetDefinition(parts[0]); if (docDef is DocEntity) { DocEntity docEnt = (DocEntity)docDef; docEnt.WhereRules.Add(docWhere); } else if (docDef is DocDefined) { DocDefined docEnt = (DocDefined)docDef; docEnt.WhereRules.Add(docWhere); } else if (docDef == null) { //... global rule... } } } else { // function string schema = Path.GetDirectoryName(file); schema = Path.GetDirectoryName(schema); schema = Path.GetFileName(schema); DocSchema docSchema = project.GetSchema(schema); if (docSchema != null) { DocFunction docFunction = new DocFunction(); docSchema.Functions.Add(docFunction); docFunction.Name = name; docFunction.Expression = expr; } } } // now, hook up html documentation en = System.IO.Directory.EnumerateFiles(pathSchema, "*.htm", System.IO.SearchOption.AllDirectories); foreach (string file in en) { string name = Path.GetFileNameWithoutExtension(file); DocObject docObj = null; if (name == "schema") { string schema = Path.GetDirectoryName(file); schema = Path.GetFileName(schema); docObj = project.GetSchema(schema); } else if (name.Contains('-')) { // where rule string[] parts = name.Split('-'); if (parts.Length == 2) { DocDefinition docDef = project.GetDefinition(parts[0]); if (docDef is DocEntity) { DocEntity docEnt = (DocEntity)docDef; foreach (DocWhereRule docWhereRule in docEnt.WhereRules) { if (docWhereRule.Name.Equals(parts[1])) { docObj = docWhereRule; break; } } } else if (docDef is DocDefined) { DocDefined docEnt = (DocDefined)docDef; foreach (DocWhereRule docWhereRule in docEnt.WhereRules) { if (docWhereRule.Name.Equals(parts[1])) { docObj = docWhereRule; break; } } } } } else { docObj = project.GetDefinition(name); if (docObj == null) { docObj = project.GetFunction(name); } } if (docObj != null) { using (StreamReader readHtml = new StreamReader(file, Encoding.UTF8)) { docObj.Documentation = readHtml.ReadToEnd(); } } } // load schema diagrams en = System.IO.Directory.EnumerateFiles(pathSchema, "*.svg", System.IO.SearchOption.AllDirectories); foreach (string file in en) { string schema = Path.GetDirectoryName(file); schema = Path.GetFileName(schema); DocSchema docSchema = project.GetSchema(schema); if (docSchema != null) { using (IfcDoc.Schema.SVG.SchemaSVG schemaSVG = new IfcDoc.Schema.SVG.SchemaSVG(file, docSchema, project)) { schemaSVG.Load(); } } } // psets, qsets //... // exchanges en = System.IO.Directory.EnumerateFiles(path, "*.mvdxml", System.IO.SearchOption.AllDirectories); foreach (string file in en) { IfcDoc.Schema.MVD.SchemaMVD.Load(project, file); } // examples string pathExamples = path + @"\examples"; if (Directory.Exists(pathExamples)) { en = System.IO.Directory.EnumerateFiles(pathExamples, "*.htm", SearchOption.TopDirectoryOnly); foreach (string file in en) { DocExample docExample = new DocExample(); docExample.Name = Path.GetFileNameWithoutExtension(file); project.Examples.Add(docExample); using (StreamReader reader = new StreamReader(file)) { docExample.Documentation = reader.ReadToEnd(); } string dirpath = file.Substring(0, file.Length - 4); if (Directory.Exists(dirpath)) { IEnumerable <string> suben = System.IO.Directory.EnumerateFiles(dirpath, "*.ifc", SearchOption.TopDirectoryOnly); foreach (string ex in suben) { DocExample docEx = new DocExample(); docEx.Name = Path.GetFileNameWithoutExtension(ex); docExample.Examples.Add(docEx); // read the content of the file using (FileStream fs = new FileStream(ex, FileMode.Open, FileAccess.Read)) { docEx.File = new byte[fs.Length]; fs.Read(docEx.File, 0, docEx.File.Length); } // read documentation string exdoc = ex.Substring(0, ex.Length - 4) + ".htm"; if (File.Exists(exdoc)) { using (StreamReader reader = new StreamReader(exdoc)) { docEx.Documentation = reader.ReadToEnd(); } } } } } } // localization en = System.IO.Directory.EnumerateFiles(path, "*.txt", System.IO.SearchOption.AllDirectories); foreach (string file in en) { using (FormatCSV format = new FormatCSV(file)) { try { format.Instance = project; format.Load(); } catch { } } } }
public FixedRequiredAttributeAdapter(ModelMetadata metadata, ControllerContext context, RequiredAttribute attribute) : base(metadata, context, attribute) { }
public RequiredIfAttribute(String propertyName, Object desiredvalue) { PropertyName = propertyName; DesiredValue = desiredvalue; _innerAttribute = new RequiredAttribute(); }
protected override IEnumerable <ModelValidator> GetValidators(ModelMetadata metadata, ControllerContext context, IEnumerable <Attribute> attributes) { List <ModelValidator> vals = base.GetValidators(metadata, context, attributes).ToList(); DataAnnotationsModelValidationFactory factory; // Inject our new validator. if (metadata.ContainerType != null) { // Check if we have validation for this class name. if (ValidationManager.Validators.ContainsKey(metadata.ContainerType.Name)) { var validator = ValidationManager.Validators[metadata.ContainerType.Name]; // Check if we have validation for this property name. if (validator.ContainsKey(metadata.PropertyName)) { var property = validator[metadata.PropertyName]; // Only add validation to visible properties. if (property.Visible) { // Required attribute. if (property.Required) { ValidationAttribute required; if (metadata.ModelType == typeof(bool)) { // For required booleans, enforce true. required = new EnforceTrueAttribute { ErrorMessage = property.ErrorMessage }; } else if (metadata.ModelType == typeof(int) || metadata.ModelType == typeof(long) || metadata.ModelType == typeof(double) || metadata.ModelType == typeof(float)) { // For required int, long, double, float (dropdownlists), enforce > 0. required = new GreaterThanZeroAttribute() { ErrorMessage = property.ErrorMessage }; } else { required = new RequiredAttribute { ErrorMessage = property.ErrorMessage }; } if (!AttributeFactories.TryGetValue(required.GetType(), out factory)) { factory = DefaultAttributeFactory; } yield return(factory(metadata, context, required)); } // Regular expression attribute. if (!string.IsNullOrEmpty(property.RegularExpression)) { RegularExpressionAttribute regEx = new RegularExpressionAttribute(property.RegularExpression) { ErrorMessage = property.ErrorMessage }; if (!AttributeFactories.TryGetValue(regEx.GetType(), out factory)) { factory = DefaultAttributeFactory; } yield return(factory(metadata, context, regEx)); } // Compare attribute. if (!string.IsNullOrEmpty(property.Compare)) { CompareAttribute compare = new CompareAttribute(property.Compare) { ErrorMessage = property.ErrorMessage }; if (!AttributeFactories.TryGetValue(compare.GetType(), out factory)) { factory = DefaultAttributeFactory; } yield return(factory(metadata, context, compare)); } } } } } }