public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            var rule = new ModelClientValidationRule()
            {
                ErrorMessage = FormatErrorMessage(metadata.GetDisplayName()),
                ValidationType = "validname",
            };

            var clientValidationRules = new List<string>
                                              {
                                                  _onlyOneEntityValidator.GetClientValidationRules(metadata,context).First().ValidationType,
                                                  _cannotBeNotApplicable.GetClientValidationRules(metadata,context).First().ValidationType,
                                                  _cannotContainNumbers.GetClientValidationRules(metadata,context).First().ValidationType,
                                              };

            var regexPatterns = new List<string>
                               {
                                   _onlyOneEntityValidator.Pattern,
                                   _cannotBeNotApplicable.Pattern,
                                   _cannotContainNumbers.Pattern,
                               };
            var errorMessages = new List<string>
                                    {
                                        _onlyOneEntityValidator.FormatErrorMessage(metadata.GetDisplayName()),
                                        _cannotBeNotApplicable.FormatErrorMessage(metadata.GetDisplayName()),
                                        _cannotContainNumbers.FormatErrorMessage(metadata.GetDisplayName())
                                    };

            rule.ValidationParameters.Add("clientvalidationrules", clientValidationRules.Aggregate((i, j) => i + "," + j));
            rule.ValidationParameters.Add("regexpatterns", regexPatterns.Aggregate((i, j) => i + "," + j));
            rule.ValidationParameters.Add("errormessages", errorMessages.Aggregate((i, j) => i + "," + j));
            yield return rule;
        }
示例#2
0
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     ModelClientValidationRule ccvAttribute = new ModelClientValidationRule();
     ccvAttribute.ErrorMessage = this.ErrorMessage;
     ccvAttribute.ValidationType = "ccv";
     yield return ccvAttribute;
 }
示例#3
0
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     var rule = new ModelClientValidationRule();
     rule.ErrorMessage = FormatErrorMessage(metadata.GetDisplayName());
     rule.ValidationType = "dbisbool";
     yield return rule;
 }
示例#4
0
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     var rule = new ModelClientValidationRule();
     rule.ErrorMessage = "true";
     rule.ValidationType = "dbisunique";
     yield return rule;
 }
        public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            var rule = new ModelClientValidationRule()
            {
                ErrorMessage = FormatErrorMessage(metadata.GetDisplayName()),
                ValidationType = "requiredifany",
            };

            var properties = new List<string>();
            var values = new List<object>();

            for (int i = 0; i < DependentProperties.Count(); i++)
            {
                string depProp = BuildDependentPropertyId(metadata, context as ViewContext, DependentProperties[i]);

                // find the value on the control we depend on;
                // if it's a bool, format it javascript style 
                // (the default is True or False!)
                string targetValue = (TargetValues[i] ?? "").ToString();
                if (TargetValues[i].GetType() == typeof(bool))
                    targetValue = targetValue.ToLower();

                properties.Add(depProp);
                values.Add(targetValue);
            }

            rule.ValidationParameters.Add("dependentproperties", String.Join("|", properties));
            rule.ValidationParameters.Add("targetvalues", String.Join("|", values));

            yield return rule;
        }
        public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            var rule = new ModelClientValidationRule()
            {
                ErrorMessage = FormatErrorMessage(metadata.GetDisplayName()),
                ValidationType = (_invertToRequiredIfNot ? "requiredifnot" : "requiredif"),
            };

            string depProp = BuildDependentPropertyId(metadata, context as ViewContext);

            // find the value on the control we depend on;
            // if it's a bool, format it JavaScript style
            // (the default is True or False!)
            StringBuilder sb = new StringBuilder();

            foreach (var obj in this._targetValues)
            {
                string targetValue = (obj ?? string.Empty).ToString();

                if (obj.GetType() == typeof(bool))
                    targetValue = targetValue.ToLower();

                sb.AppendFormat("|{0}", targetValue);
            }

            rule.ValidationParameters.Add("dependentproperty", depProp);
            rule.ValidationParameters.Add("targetvalue", sb.ToString().TrimStart('|'));

            yield return rule;
        }
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     var rule = new ModelClientValidationRule();
     rule.ValidationType = "gangmember";
     rule.ErrorMessage = "You must be in the gang";
     yield return rule;
 }
        /// <summary>
        /// When implemented in a class, returns client validation rules for that class.
        /// </summary>
        /// <param name="metadata">The model metadata.</param>
        /// <param name="context">The controller context.</param>
        /// <returns>
        /// The client validation rules for this validator.
        /// </returns>
        public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            var rule = new ModelClientValidationRule { ErrorMessage = ErrorMessageString ?? "The field must not contain any of the following characters: \" / \\ [ ] : ; | = , + * ? < > %", ValidationType = clientValidationRule };
            rule.ValidationParameters.Add("pattern", RootModuleConstants.ActiveDirectoryNonCompliantExpression);

            yield return rule;
        }
        protected string MessageOrDefault(ModelClientValidationRule rule, string propertyName)
        {
            // We don't want to display the default {validator.*} messages
            if ((rule.ErrorMessage != null) && !rule.ErrorMessage.StartsWith("{validator."))
                return rule.ErrorMessage;

            switch (rule.ValidationType)
            {
                case "stringLength":
                    var maxLength = (int)rule.ValidationParameters["maximumLength"];
                    return
                        new StringLengthAttribute(maxLength).FormatErrorMessage(propertyName);
                case "required":
                    return new RequiredAttribute().FormatErrorMessage(propertyName);
                case "range":
                    var min = Convert.ToDouble(rule.ValidationParameters["minimum"]);
                    var max = Convert.ToDouble(rule.ValidationParameters["maximum"]);
                    return
                        new System.ComponentModel.DataAnnotations.RangeAttribute(min, max).FormatErrorMessage(propertyName);
                case "regularExpression":
                    var pattern = (string)rule.ValidationParameters["pattern"];
                    return new RegularExpressionAttribute(pattern).FormatErrorMessage(propertyName);
                default:
                    throw new NotSupportedException(
                        "Only stringLength, Required, Range and RegularExpression validators are supported for generic error messages. Add a custom error message or choose another validator type");
            }
        }
示例#10
0
        /// <summary>
        /// When implemented in a class, returns client validation rules for that class.
        /// </summary>
        /// <param name="metadata">The model metadata.</param>
        /// <param name="context">The controller context.</param>
        /// <returns>
        /// The client validation rules for this validator.
        /// </returns>
        public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            var rule = new ModelClientValidationRule { ErrorMessage = ErrorMessageString ?? "Field must not contain HTML.", ValidationType = clientValidationRule };
            rule.ValidationParameters.Add("pattern", RootModuleConstants.HtmlRegularExpression);

            yield return rule;
        }
        protected override void SetModelValidationRule(ModelClientValidationRule rule)
        {
            base.SetModelValidationRule(rule);

            switch (rule.ValidationType)
            {
                case "required":
                    this.AllowBlank = false;
                    this.BlankText = rule.ErrorMessage;
                    break;
                case "range":
                    if (rule.ValidationParameters.ContainsKey("max"))
                    {
                        this.MaxSelections = (int)Convert.ChangeType(rule.ValidationParameters["max"], typeof(int));
                        this.MaxSelectionsText = rule.ErrorMessage;
                    }

                    if (rule.ValidationParameters.ContainsKey("min"))
                    {
                        this.MinSelections = (int)Convert.ChangeType(rule.ValidationParameters["min"], typeof(int));
                        this.MinSelectionsText = rule.ErrorMessage;
                    }
                    break;
            }
        }
        public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            var rule = new ModelClientValidationRule
            {
                ErrorMessage = string.Format(ErrorMessage, metadata.GetDisplayName()),
                ValidationType = "requiredif",
            };

            var viewContext = (ViewContext)context;
            var oldPrefix = viewContext.ViewData.TemplateInfo.HtmlFieldPrefix;

            // only strip prefix when it exists
            viewContext.ViewData.TemplateInfo.HtmlFieldPrefix = string.Empty;
            var otherInputName = viewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(OtherProperty);
            var thisPropertyName = ".{0}".FormatWith(metadata.PropertyName);
            if (oldPrefix.EndsWith(thisPropertyName))
            {
                viewContext.ViewData.TemplateInfo.HtmlFieldPrefix = oldPrefix.Replace(thisPropertyName, string.Empty);
                otherInputName = viewContext
                    .ViewData
                    .TemplateInfo
                    .GetFullHtmlFieldName(OtherProperty);
            }
            viewContext.ViewData.TemplateInfo.HtmlFieldPrefix = oldPrefix;

            rule.ValidationParameters.Add("otherinputname", otherInputName);
            rule.ValidationParameters.Add("comparisontype", ComparisonType);
            rule.ValidationParameters.Add("othercomparisonvalue", OtherComparisonValue);


            yield return rule;
        }
        /// <summary>
        /// When implemented in a class, returns client validation rules for that class.
        /// </summary>
        /// <param name="metadata">The model metadata.</param>
        /// <param name="context">The controller context.</param>
        /// <returns>
        /// The client validation rules for this validator.
        /// </returns>
        public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            var rule = new ModelClientValidationRule { ErrorMessage = ErrorMessageString ?? "Field invalid. Field can only contain alphanumeric characters: 'a-z', 'A-Z', '0-9'.", ValidationType = clientValidationRule };
            rule.ValidationParameters.Add("pattern", RootModuleConstants.AlphanumericExpression);

            yield return rule;
        }
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     var existsRule = new ModelClientValidationRule { ValidationType = "existsin", ErrorMessage = FormatErrorMessage(metadata.DisplayName ?? metadata.PropertyName) };
     existsRule.ValidationParameters["collection"] = Collection;
     existsRule.ValidationParameters["value"] = Value;
     existsRule.ValidationParameters["display"] = Display;
     yield return existsRule;
 }
        public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            var rule = new ModelClientValidationRule();
            rule.ErrorMessage = ErrorMessage;
            rule.ValidationType = "requiredchecked";

            yield return rule;
        }
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     var rule = new ModelClientValidationRule();
     rule.ErrorMessage = FormatErrorMessage(metadata.DisplayName);
     rule.ValidationType = "morethen";
     rule.ValidationParameters.Add("id", _elemName);
     yield return rule;
 }
示例#17
0
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     var rule = new ModelClientValidationRule();
     rule.ErrorMessage = this.FormatErrorMessage(metadata.PropertyName);
     rule.ValidationType = "min";
     rule.ValidationParameters.Add("value",minValue);
     yield return rule;
 }
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     ModelClientValidationRule requiredIfNull = new ModelClientValidationRule();
     requiredIfNull.ErrorMessage = this.ErrorMessage;
     requiredIfNull.ValidationType = "requiredifpropertiesisnull";
     requiredIfNull.ValidationParameters.Add("properties", string.Join(",", this.Properties));
     yield return requiredIfNull;
 }
示例#19
0
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(
     ModelMetadata metadata, ControllerContext context)
 {
     var rule = new ModelClientValidationRule
                    {ErrorMessage = FormatErrorMessage(metadata.GetDisplayName()), ValidationType = "greater"};
     rule.ValidationParameters.Add("other", OtherPropertyName);
     yield return rule;
 }
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     var rule = new ModelClientValidationRule();
     rule.ErrorMessage = FormatErrorMessage(metadata.DisplayName);
     rule.ValidationType = "startsafter";
     rule.ValidationParameters.Add("date", DateTime.Today.ToString(CultureInfo.InvariantCulture));
     yield return rule;
 }
示例#21
0
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     string errorMessage = FormatErrorMessage("");
     ModelClientValidationRule rule = new ModelClientValidationRule { ValidationType = "agerange", ErrorMessage = errorMessage };
     rule.ValidationParameters.Add("minage", this.Minimum);
     rule.ValidationParameters.Add("maxage", this.Maximum);
     yield return rule;
 }
示例#22
0
 //implement the method of IClientValidatable interface to make the attribute client validatable
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     var rule = new ModelClientValidationRule();
     rule.ErrorMessage = FormatErrorMessage(metadata.DisplayName);
     rule.ValidationParameters.Add("wordcount",_maxWords);
     rule.ValidationType = "maxwords";
     yield return rule;
 }
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context) {
     var rule = new ModelClientValidationRule {
         ValidationType = "accept",
         ErrorMessage = FormatErrorMessage(metadata.GetDisplayName())
     };
     rule.ValidationParameters["exts"] = ExtensionsNormalized;
     yield return rule;
 }
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     var rule = new ModelClientValidationRule();
     rule.ErrorMessage = FormatErrorMessage(metadata.GetDisplayName());
     rule.ValidationParameters.Add("text", Text);
     rule.ValidationType = "mustcontain";
     yield return rule;
 }
 public ModelClientValidationDelegating(ModelClientValidationRule innerValidatoinRule, Expression expression)
 {
     base.ErrorMessage = innerValidatoinRule.ErrorMessage;
     base.ValidationType = "wrappedRule";
     base.ValidationParameters.Add("ruleType", Convert.ToString(innerValidatoinRule.ValidationType));
     base.ValidationParameters.Add("ruleParams", innerValidatoinRule.ValidationParameters );
     base.ValidationParameters.Add("expression", ExpressionParser.ConvertToJSCompliantString(expression));
 }
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     var rule = new ModelClientValidationRule();
     rule.ErrorMessage = ErrorMessage;
     rule.ValidationParameters.Add("min", _minValue);
     rule.ValidationType = "range";
     yield return rule;
 }
            public override IEnumerable<ModelClientValidationRule> GetClientValidationRules() {
                ModelClientValidationRule rule = new ModelClientValidationRule() {
                    ValidationType = "number",
                    ErrorMessage = MakeErrorString(Metadata.GetDisplayName())
                };

                return new ModelClientValidationRule[] { rule };
            }
示例#28
0
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     var rule = new ModelClientValidationRule()
     {
         ErrorMessage = this.FormatErrorMessage(metadata.DisplayName),
         ValidationType = "MustBeTrue"
     };
     yield return rule;
 }
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     var rule = new ModelClientValidationRule();
     rule.ErrorMessage = FormatErrorMessage(metadata.GetDisplayName());
     rule.ValidationParameters.Add("expressions", expressions);
     rule.ValidationType = derivedType;
     //rule.ValidationType = "genericphonevalidationhandler";
     yield return rule;
 }
示例#30
0
 public IEnumerable<ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
 {
     var rule = new ModelClientValidationRule
     {
         ErrorMessage = this.ErrorMessageString,
         ValidationType = "istrue"
     };
     yield return rule;
 }
        private static void ValidateUnobtrusiveValidationRule(ModelClientValidationRule rule, IDictionary <string, object> resultsDictionary, string dictionaryKey)
        {
            if (String.IsNullOrWhiteSpace(rule.ValidationType))
            {
                throw new InvalidOperationException(
                          String.Format(
                              CultureInfo.CurrentCulture,
                              WebPageResources.UnobtrusiveJavascript_ValidationTypeCannotBeEmpty,
                              rule.GetType().FullName));
            }

            if (resultsDictionary.ContainsKey(dictionaryKey))
            {
                throw new InvalidOperationException(
                          String.Format(
                              CultureInfo.CurrentCulture,
                              WebPageResources.UnobtrusiveJavascript_ValidationTypeMustBeUnique,
                              rule.ValidationType));
            }

            if (rule.ValidationType.Any(c => !Char.IsLower(c)))
            {
                throw new InvalidOperationException(
                          String.Format(CultureInfo.CurrentCulture, WebPageResources.UnobtrusiveJavascript_ValidationTypeMustBeLegal,
                                        rule.ValidationType,
                                        rule.GetType().FullName));
            }

            foreach (var key in rule.ValidationParameters.Keys)
            {
                if (String.IsNullOrWhiteSpace(key))
                {
                    throw new InvalidOperationException(
                              String.Format(
                                  CultureInfo.CurrentCulture,
                                  WebPageResources.UnobtrusiveJavascript_ValidationParameterCannotBeEmpty,
                                  rule.GetType().FullName));
                }

                if (!Char.IsLower(key.First()) || key.Any(c => !Char.IsLower(c) && !Char.IsDigit(c)))
                {
                    throw new InvalidOperationException(
                              String.Format(
                                  CultureInfo.CurrentCulture,
                                  WebPageResources.UnobtrusiveJavascript_ValidationParameterMustBeLegal,
                                  key,
                                  rule.GetType().FullName));
                }
            }
        }
        /// <summary>
        /// When implemented in a class, returns client validation rules for that class.
        /// </summary>
        /// <param name="metadata">The model metadata.</param>
        /// <param name="context">The controller context.</param>
        /// <returns>
        /// The client validation rules for this validator.
        /// </returns>
        public IEnumerable <ModelClientValidationRule> GetClientValidationRules(ModelMetadata metadata, ControllerContext context)
        {
            if (string.IsNullOrEmpty(GroupName))
            {
                yield break;
            }
            var rule = new ModelClientValidationRule
            {
                ValidationType = "valgroup"
                ,
                ErrorMessage = string.Empty
            };

            rule.ValidationParameters["name"] = GroupName;
            yield return(rule);
        }
 public static HtmlString GenerateHtmlAttributes(this ModelClientValidationRule clientRule)
 {
     return(new[] { clientRule }.GenerateHtmlAttributes());
 }