Example #1
0
        internal static void BsSelectListValidation(this TagBuilder tagBuilder, HtmlHelper htmlHelper, string name, ModelMetadata metadata = null)
        {
            // If there are any errors for a named field, we add the css attribute.
            ModelState modelState;

            if (htmlHelper.ViewData.ModelState.TryGetValue(name, out modelState))
            {
                if (modelState.Errors.Count > 0)
                {
                    tagBuilder.AddCssClass(HtmlHelper.ValidationInputCssClassName);
                }
            }

            //Validation Hack
            name = name.Replace(".SelectedValues", "");

            var attributes = htmlHelper.GetUnobtrusiveValidationAttributes(name, metadata);

            if (name.Contains(".") && !attributes.Any())
            {
                attributes = htmlHelper.GetUnobtrusiveValidationAttributes(name.Split('.').LastOrDefault());
            }

            tagBuilder.MergeAttributes(attributes);
        }
Example #2
0
        public static string RenderFile(HtmlHelper html, BootstrapFileModel model)
        {
            string validationMessage = "";

            if (model.displayValidationMessage)
            {
                string validation = html.ValidationMessage(model.htmlFieldName).ToHtmlString();
                validationMessage = new BootstrapHelpText(validation, model.validationMessageStyle).ToHtmlString();
            }

            model.htmlAttributes.MergeHtmlAttributes(html.GetUnobtrusiveValidationAttributes(model.htmlFieldName, model.metadata));

            if (model.tooltipConfiguration != null)
            {
                model.htmlAttributes.MergeHtmlAttributes(model.tooltipConfiguration.ToDictionary());
            }
            if (model.tooltip != null)
            {
                model.htmlAttributes.MergeHtmlAttributes(model.tooltip.ToDictionary());
            }

            var mergedHtmlAttrs = model.htmlAttributes.FormatHtmlAttributes().AddOrReplace("type", "File");

            if (!string.IsNullOrEmpty(model.id))
            {
                mergedHtmlAttrs.AddOrReplace("id", model.id);
            }

            return(html.TextBox(model.htmlFieldName, null, mergedHtmlAttrs).ToHtmlString() + validationMessage);
        }
Example #3
0
        private static TagBuilder AutocompleteVisibleImpl(HtmlHelper helper, string name,
                                                          string value, string listUrl, string validateUrl, RouteValueDictionary htmlAttributes)
        {
            // Visible Textbox
            var input = new TagBuilder("input");

            input.Attributes.Add("type", "text");
            input.Attributes.Add("data-ac-list-url", listUrl);
            if (!string.IsNullOrEmpty(validateUrl))
            {
                input.Attributes.Add("data-ac-validate-url", validateUrl);
            }
            input.Attributes.Add("name", name);
            if (!string.IsNullOrEmpty(value))
            {
                input.Attributes.Add("value", value);
            }

            input.MergeAttributes(helper.GetUnobtrusiveValidationAttributes(name), true);

            if (htmlAttributes != null)
            {
                input.MergeAttributes(htmlAttributes, true);
            }
            return(input);
        }
Example #4
0
        private static string InputTagHelper(HtmlHelper htmlHelper, ModelMetadata metadata, string expression, IDictionary <string, object> htmlAttributes, string fullName, int index, string fieldType, string val)
        {
            // Create the input tag with the specified parameters
            var tagBuilder = new TagBuilder("input");

            tagBuilder.MergeAttributes(htmlAttributes);
            tagBuilder.MergeAttribute("type", HtmlHelper.GetInputTypeString(InputType.Hidden));
            tagBuilder.MergeAttribute("value", val);

            // The name is the most important part of the tag building, as using the correct name
            // will ensure that the default model binder will correctly be able to deserialize the dictionary
            tagBuilder.MergeAttribute("name", string.Format("{0}[{1}].{2}", fullName, index, fieldType), true);

            tagBuilder.GenerateId(fullName);

            // If there are any errors for the named field, we add the css attribute.
            ModelState modelState;

            if (htmlHelper.ViewData.ModelState.TryGetValue(fullName, out modelState))
            {
                if (modelState.Errors.Count > 0)
                {
                    tagBuilder.AddCssClass(HtmlHelper.ValidationInputCssClassName);
                }
            }

            // Merge the unobtrusive validation attributes (if there are any)
            tagBuilder.MergeAttributes(htmlHelper.GetUnobtrusiveValidationAttributes(expression, metadata));

            return(tagBuilder.ToString(TagRenderMode.SelfClosing));
        }
Example #5
0
        public static MvcHtmlString DatePickerFor <TModel, TProperty> (this HtmlHelper <TModel> helper, Expression <Func <TModel, TProperty> > expression, string cssClass)
        {
            var datePickerName     = ExpressionHelper.GetExpressionText(expression);
            var datePickerFullName = helper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(datePickerName);
            var datePickerID       = TagBuilder.CreateSanitizedId(datePickerFullName);

            var metadata        = ModelMetadata.FromLambdaExpression(expression, helper.ViewData);
            var datePickerValue = (metadata.Model == null ? DateTime.Now : DateTime.Parse(metadata.Model.ToString()));

            var tag = new TagBuilder("input");

            tag.Attributes.Add("name", datePickerFullName);
            tag.Attributes.Add("id", datePickerID);
            tag.Attributes.Add("type", "text");
            tag.Attributes.Add("value", datePickerValue.ToString());
            tag.Attributes.Add("class", "form-control");

            IDictionary <string, object> validationAttributes = helper.GetUnobtrusiveValidationAttributes(datePickerFullName, metadata);

            foreach (var key in validationAttributes.Keys)
            {
                tag.Attributes.Add(key, validationAttributes[key].ToString());
            }

            var html = new MvcHtmlString(tag.ToString(TagRenderMode.SelfClosing) + "<span class='input-group-addon'><span class='glyphicon glyphicon-calendar'></span></span>");

            return(html);
        }
        public static MvcHtmlString KingRadioButtonListFor <TModel, TProperty>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TProperty> > expression, string name, IEnumerable <SelectListItem> dataScource, ValidateOptions validateOption = null, RepeatDirection repeatDirection = 0, object htmlAttributes = null, bool IsDefaultStyle = true, bool readOnly = false)
        {
            ModelMetadata metadata       = ModelMetadata.FromLambdaExpression <TModel, TProperty>(expression, htmlHelper.ViewData);
            string        expressionText = ExpressionHelper.GetExpressionText(expression);
            IDictionary <string, object> unobtrusiveValidationAttributes = htmlHelper.GetUnobtrusiveValidationAttributes(expressionText, metadata);
            string fullHtmlFieldName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(expressionText);
            string defaultValue      = "";

            if (ValidateCommon.GetModelType(metadata.ModelType) == typeof(bool))
            {
                if (metadata.Model != null)
                {
                    defaultValue = ((bool)metadata.Model) ? "1" : "0";
                }
                else
                {
                    defaultValue = "0";
                }
            }
            else
            {
                defaultValue = (metadata.Model == null) ? "" : metadata.Model.ToString();
            }
            return(MvcHtmlString.Create(GenerateHtml(name, dataScource, validateOption, HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes), repeatDirection, defaultValue, IsDefaultStyle, readOnly) + AddJs(htmlHelper)));
        }
Example #7
0
        public static MvcHtmlString CheckBoxListForModel <T> (this HtmlHelper htmlHelper,
                                                              IEnumerable <T> items,
                                                              string value,
                                                              string text,
                                                              object htmlAttributes = null)
        {
            var propertyName = htmlHelper.ViewData.ModelMetadata.PropertyName;

            var enumerableModel = htmlHelper.ViewData.Model as IEnumerable;

            //Convert selected value list to a List<string> for easy manipulation
            var selectedValues = enumerableModel != null?enumerableModel.OfType <T>() : Enumerable.Empty <T>();

            //Create div
            var divTag = new TagBuilder("div");

            divTag.MergeAttributes(new RouteValueDictionary(htmlAttributes), true);
            divTag.MergeAttributes(htmlHelper.GetUnobtrusiveValidationAttributes(propertyName, htmlHelper.ViewData.ModelMetadata));
            const string labelAndCheckboxDiv = "<label tabIndex=\"{4}\"><input type=\"checkbox\" name=\"{0}\" id=\"{0}_{1}\" " +
                                               "value=\"{1}\" {2} />{3}</label>";

            var innerHtmlBuilder = new StringBuilder( );

            foreach (var item in items)
            {
                innerHtmlBuilder.Append(String.Format(labelAndCheckboxDiv,
                                                      propertyName,
                                                      DataBinder.Eval(item, value),
                                                      selectedValues.Contains(item) ? "checked=\"checked\"" : "",
                                                      DataBinder.Eval(item, text),
                                                      0));
            }
            divTag.InnerHtml = innerHtmlBuilder.ToString( );
            return(MvcHtmlString.Create(divTag.ToString( )));
        }
Example #8
0
        public static MvcHtmlString SemanticDropDownBoolFor <TModel, TProperty>(this HtmlHelper <TModel> html, Expression <Func <TModel, TProperty> > expression, string optionLabel, object htmlAttributes, bool value)
        {
            var fullBindingName = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(expression));
            var metadata        = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
            var validations     = html.GetUnobtrusiveValidationAttributes(metadata.PropertyName, metadata);
            var tag             = new TagBuilder("select");

            InsertValidateAttribute(tag, validations);
            if (htmlAttributes != null)
            {
                tag.MergeAttributes(HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
            }
            if (tag.Attributes.ContainsKey("class"))
            {
                tag.Attributes["class"] = $"ui fluid dropdown {tag.Attributes["class"]}";
            }
            else
            {
                tag.Attributes.Add("class", "ui fluid dropdown");
            }
            tag.Attributes.Add("id", TagBuilder.CreateSanitizedId(fullBindingName));
            tag.Attributes.Add("name", fullBindingName);
            tag.InnerHtml += $"<option value=''>{optionLabel}</option>";
            if (value)
            {
                tag.InnerHtml += "<option value='true' selected>Sim</option>";
                tag.InnerHtml += "<option value='false'>Não</option>";
            }
            else
            {
                tag.InnerHtml += "<option value='true'>Sim</option>";
                tag.InnerHtml += "<option value='false' selected>Não</option>";
            }
            return(new MvcHtmlString(tag.ToString()));
        }
        public static MvcHtmlString NumberBox <TModel, TValue>(this HtmlHelper <TModel> helper, Expression <Func <TModel, TValue> > expression, IEnumerable <SelectListItem> list, object htmlAttributes = null)
        {
            var    data         = ModelMetadata.FromLambdaExpression(expression, helper.ViewData);
            string propertyName = data.PropertyName;

            TagBuilder dropdown = new TagBuilder("select");

            dropdown.Attributes.Add("name", propertyName);
            dropdown.MergeAttribute("class", "form-control no-arrow");
            dropdown.MergeAttribute("type", "number");

            dropdown.MergeAttributes(helper.GetUnobtrusiveValidationAttributes(propertyName));  //hata mesajı
            dropdown.MergeAttribute("style", "width:50px");
            StringBuilder options = new StringBuilder();

            foreach (var item in list)
            {
                options = options.Append("<option value='" + item.Value + "'>" + item.Text + "</option>");
            }
            options.Append("<input name='codeNum'  class='form-control no-arrow' style='width:40px' type='number' required='required' minlength='3' maxlength='3'/> "); //alan kodu
            options.Append("<span class='input-group-addon'>-</span>");
            options.Append("<input name='thirdNum'  class='form-control no-arrow' style='' type='number' required='required' minlength='3' maxlength='3' /> ");         //numaranın geri kalan kısmı
            options.Append("<span class='input-group-addon'>-</span>");
            options.Append("<input name='fourthNum'  class='form-control no-arrow' style='width:50px' type='number' required='required' minlength='4' maxlength='4' />");

            dropdown.InnerHtml = options.ToString();

            if (htmlAttributes != null)
            {
                var attributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
                dropdown.MergeAttributes(attributes);
            }

            return(new MvcHtmlString(dropdown.ToString()));
        }
Example #10
0
        public static HtmlString SimpleEditorFor <TModel, TValue>(this HtmlHelper <TModel> helper, Expression <Func <TModel, TValue> > expression, object htmlAttributes)
        {
            string     htmlFieldName = ExpressionHelper.GetExpressionText(expression);
            string     fullName      = helper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(htmlFieldName);
            string     defaultValue  = HttpContext.Current.Request.Form[fullName];
            TagBuilder tb            = new TagBuilder("input");

            tb.Attributes.Add("id", fullName);
            tb.Attributes.Add("name", fullName);
            if (htmlAttributes != null)
            {
                var attributes = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
                tb.MergeAttributes(attributes);
            }
            ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, helper.ViewData);

            ModelState modelState;

            if (helper.ViewData.ModelState.TryGetValue(fullName, out modelState))
            {
                if (modelState.Errors.Count > 0)
                {
                    tb.AddCssClass(HtmlHelper.ValidationInputCssClassName);
                }
            }

            tb.MergeAttributes(helper.GetUnobtrusiveValidationAttributes(htmlFieldName, metadata));
            return(MvcHtmlString.Create(tb.ToString(TagRenderMode.SelfClosing)));
        }
        public static IHtmlString UploadFileFor <TModel, TValue>(this HtmlHelper <TModel> helper, Expression <Func <TModel, TValue> > expression, Object htmlAttributes = null)
        {
            var builder  = new TagBuilder("input");
            var name     = ExpressionHelper.GetExpressionText(expression);
            var metadata = ModelMetadata.FromLambdaExpression(expression, helper.ViewData);

            builder.GenerateId(name);
            builder.MergeAttribute("name", name);
            builder.MergeAttribute("type", "file");
            IDictionary <string, object> validationAttributes = helper.
                                                                GetUnobtrusiveValidationAttributes
                                                                    (name, metadata);

            foreach (string key in validationAttributes.Keys)
            {
                builder.Attributes.Add(key, validationAttributes[key].ToString());
            }
            if (htmlAttributes != null)
            {
                IDictionary <string, string> newAttributes = (IDictionary <string, string>)(htmlAttributes);

                foreach (var attr in newAttributes)
                {
                    builder.Attributes.Add(attr.Key, attr.Value);
                }
            }
            builder.MergeAttributes(new RouteValueDictionary(htmlAttributes));
            return(MvcHtmlString.Create(builder.ToString(TagRenderMode.SelfClosing)));
        }
Example #12
0
        public static MvcHtmlString SemanticDropDownListFor <TModel, TProperty>(this HtmlHelper <TModel> html, Expression <Func <TModel, TProperty> > expression, IEnumerable <SelectListItem> selectList, string optionLabel = "Selecione...", object htmlAttributes = null)
        {
            var fullBindingName = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(expression));
            var metadata        = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
            var validations     = html.GetUnobtrusiveValidationAttributes(metadata.PropertyName, metadata);
            var tag             = new TagBuilder("div");

            InsertValidateAttribute(tag, validations);

            if (htmlAttributes != null)
            {
                tag.MergeAttributes(HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
            }

            tag.Attributes.Add("id", TagBuilder.CreateSanitizedId(fullBindingName));
            tag.AddCssClass("ui selection dropdown");
            var selectListItems = selectList as SelectListItem[] ?? selectList.ToArray();

            tag.InnerHtml = $"<input name='{fullBindingName}' type='hidden' value='{selectListItems.FirstOrDefault(f => f.Selected)?.Value}'>";

            tag.InnerHtml += $"<div class='default text'>{optionLabel}</div>";
            tag.InnerHtml += "<div class='menu'>";

            foreach (var item in selectListItems)
            {
                tag.InnerHtml += $"<div class='item' data-value='{item.Value}' {(item.Selected ? "selected" : string.Empty)}>{item.Text}</div>";
            }

            tag.InnerHtml += "</div>";//close menu div
            return(new MvcHtmlString(tag.ToString()));
        }
Example #13
0
        private static MvcHtmlString UploadHelper(HtmlHelper htmlHelper, string name, string accept, bool multiple, IDictionary <string, object> htmlAttributes)
        {
            string fullHtmlFieldName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(name);

            if (string.IsNullOrEmpty(fullHtmlFieldName))
            {
                throw new ArgumentException("name");
            }

            TagBuilder tagBuilder = new TagBuilder("input");

            tagBuilder.MergeAttribute("type", "file");
            tagBuilder.GenerateId(fullHtmlFieldName);
            tagBuilder.MergeAttribute("name", fullHtmlFieldName, true);
            tagBuilder.MergeAttributes <string, object>(htmlAttributes, true);
            if (!String.IsNullOrEmpty(accept))
            {
                tagBuilder.MergeAttribute("accept", accept);
            }
            if (multiple)
            {
                tagBuilder.MergeAttribute("multiple", null);
            }

            ModelState state;

            if (htmlHelper.ViewData.ModelState.TryGetValue(fullHtmlFieldName, out state) && (state.Errors.Count > 0))
            {
                tagBuilder.AddCssClass(HtmlHelper.ValidationInputCssClassName);
            }

            tagBuilder.MergeAttributes <string, object>(htmlHelper.GetUnobtrusiveValidationAttributes(name));

            return(new MvcHtmlString(tagBuilder.ToString(TagRenderMode.SelfClosing)));
        }
Example #14
0
        public static MvcHtmlString SemanticEnumDropDownListFor <TModel, TProperty>(this HtmlHelper <TModel> html, Expression <Func <TModel, TProperty> > expression, string optionLabel = "Selecione...", object htmlAttributes = null)
        {
            var fullBindingName = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(expression));
            var metadata        = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
            var validations     = html.GetUnobtrusiveValidationAttributes(metadata.PropertyName, metadata);
            var tag             = new TagBuilder("select");

            InsertValidateAttribute(tag, validations);

            if (htmlAttributes != null)
            {
                tag.MergeAttributes(HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
            }

            if (tag.Attributes.ContainsKey("class"))
            {
                tag.Attributes["class"] = $"ui fluid search dropdown {tag.Attributes["class"]}";
            }
            else
            {
                tag.Attributes.Add("class", "ui fluid search dropdown");
            }

            tag.Attributes.Add("id", TagBuilder.CreateSanitizedId(fullBindingName));
            tag.Attributes.Add("name", fullBindingName);
            tag.InnerHtml += $"<option value=''>{optionLabel}</option>";

            foreach (Enum item in Enum.GetValues(Nullable.GetUnderlyingType(typeof(TProperty)) ?? typeof(TProperty)))
            {
                tag.InnerHtml += $"<option value='{item}' {(Equals(item, metadata.Model) ? "selected" : string.Empty)}>{EnumDescription.Get(item)}</option>";
            }

            return(new MvcHtmlString(tag.ToString()));
        }
Example #15
0
        public static IHtmlString EnumCheckboxListFor <TModel, TEnum>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TEnum> > expression, object htmlAttributes)
        {
            var htmlAttributesList = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);

            string name = GetDropDownListName(htmlHelper, expression, htmlAttributesList);
            IEnumerable <SelectListItem> selectList = htmlHelper.GetSelectListItemsFor <TModel, TEnum>(expression);

            var metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
            var divTag   = new TagBuilder("div");

            // Add the validation attributes
            ModelState modelState;

            if (htmlHelper.ViewData.ModelState.TryGetValue(name, out modelState))
            {
                if (modelState.Errors.Count > 0)
                {
                    divTag.AddCssClass(HtmlHelper.ValidationInputCssClassName);
                }
            }
            divTag.MergeAttributes(htmlHelper.GetUnobtrusiveValidationAttributes(name, metadata));


            divTag.MergeAttribute("class", "radio");



            foreach (var item in selectList)
            {
                var radioButtonTag = RadioButton(htmlHelper, name, item, htmlAttributesList);
                divTag.InnerHtml += radioButtonTag;
            }

            return(new HtmlString(divTag.ToString()));
        }
Example #16
0
        public static MvcHtmlString SemanticDropDownListFor <TModel, TProperty>(this HtmlHelper <TModel> html, Expression <Func <TModel, TProperty> > expression, IEnumerable <SelectListItem> selectList, string optionLabel = "Selecione...", object htmlAttributes = null)
        {
            var fullBindingName = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(expression));
            var metadata        = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
            var validations     = html.GetUnobtrusiveValidationAttributes(metadata.PropertyName, metadata);
            var tag             = new TagBuilder("select");

            InsertValidateAttribute(tag, validations);

            if (htmlAttributes != null)
            {
                tag.MergeAttributes(HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
            }

            tag.Attributes.Add("id", TagBuilder.CreateSanitizedId(fullBindingName));
            tag.Attributes.Add("name", fullBindingName);
            tag.AddCssClass("ui search dropdown");

            tag.InnerHtml += $"<option value=''>{optionLabel}</option>";
            if (selectList == null)
            {
                return(new MvcHtmlString(tag.ToString()));
            }

            foreach (var item in selectList)
            {
                tag.InnerHtml += $"<option value='{item.Value}' {(item.Selected ? "selected" : string.Empty)}>{item.Text}</option>";
            }

            return(new MvcHtmlString(tag.ToString()));
        }
Example #17
0
        public static MvcHtmlString Custom_Editor <TModel, TValue>(this HtmlHelper <TModel> html, Expression <Func <TModel, TValue> > expression, object additionalViewData)
        {
            var fieldName       = ExpressionHelper.GetExpressionText(expression);
            var fullBindingName = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(fieldName);
            var fieldId         = TagBuilder.CreateSanitizedId(fullBindingName);

            var metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
            var value    = metadata.Model;

            TagBuilder tag = new TagBuilder("input");

            tag.Attributes.Add("name", fullBindingName);
            tag.Attributes.Add("id", fieldId);
            tag.Attributes.Add("type", "text");
            tag.Attributes.Add("value", value == null ? "" : value.ToString());
            tag.Attributes.Add("style", "background-color:yellow");

            var validationAttributes = html.GetUnobtrusiveValidationAttributes(fullBindingName, metadata);

            foreach (var key in validationAttributes.Keys)
            {
                tag.Attributes.Add(key, validationAttributes[key].ToString());
            }

            return(new MvcHtmlString(tag.ToString(TagRenderMode.SelfClosing)));
        }
        public static IDictionary <string, object> GetUnobtrusiveValidationAttributes(this IViewComponent instance)
        {
#if MVC3
            var viewContext = instance.ViewContext;

            if (viewContext.UnobtrusiveJavaScriptEnabled)
            {
                var name       = instance.Name;
                var viewData   = viewContext.ViewData;
                var htmlPrefix = viewData.TemplateInfo.HtmlFieldPrefix;

                if (name.HasValue() && htmlPrefix.HasValue() && name != htmlPrefix && name.StartsWith(htmlPrefix, StringComparison.Ordinal))
                {
                    name = name.Substring(htmlPrefix.Length + 1);
                }

                var metadata   = ModelMetadata.FromStringExpression(name, viewData);
                var htmlHelper = new HtmlHelper(viewContext, new ViewComponentViewDataContainer {
                    ViewData = viewData
                });

                if (metadata.ContainerType == null)
                {
                    metadata = viewContext.ViewData.ModelMetadata;
                }

                return(htmlHelper.GetUnobtrusiveValidationAttributes(name, metadata));
            }
#endif
            return(null);
        }
        public static ModelPropertyAttribute BeginProperty <TModel, TProperty>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TProperty> > expression)
        {
            ModelMetadata metadata       = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
            string        expressionText = ExpressionHelper.GetExpressionText(expression);

            ModelPropertyAttribute propertyAttribute = new ModelPropertyAttribute()
            {
                ID                = htmlHelper.ViewData.TemplateInfo.GetFullHtmlFieldId(expressionText),
                Name              = htmlHelper.ViewData.TemplateInfo.GetFullHtmlFieldName(expressionText),
                PropertyName      = expressionText,
                Value             = htmlHelper.Value(expressionText),
                ValidationMessage = htmlHelper.ValidationMessage(expressionText)
            };

            StringBuilder sb = new StringBuilder();

            var attributes = htmlHelper.GetUnobtrusiveValidationAttributes(expressionText, metadata);

            foreach (var keyValue in attributes)
            {
                sb
                .Append(keyValue.Key)
                .Append("=\"")
                .Append(htmlHelper.Encode(keyValue.Value))
                .Append('"');
            }

            propertyAttribute.ValidationAttributes = MvcHtmlString.Create(sb.ToString());

            return(propertyAttribute);
        }
Example #20
0
        public void GetUnobtrusiveValidationAttributesUsesShortNameForModelMetadataLookup()
        {
            // Arrange
            string passedName  = null;
            var    formContext = new FormContext();
            var    viewContext = new Mock <ViewContext>();
            var    viewData    = new ViewDataDictionary();

            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            var viewDataContainer = MvcHelper.GetViewDataContainer(viewData);
            var htmlHelper        = new HtmlHelper(viewContext.Object, viewDataContainer);

            htmlHelper.ClientValidationRuleFactory = (name, _) => {
                passedName = name;
                return(Enumerable.Empty <ModelClientValidationRule>());
            };

            // Act
            htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.AreEqual("foobar", passedName);
        }
Example #21
0
        private static MvcHtmlString CustomDropdownList(this HtmlHelper htmlHelper, ModelMetadata metadata, string name, string optionLabel, IEnumerable <SelectListItem> list, IDictionary <string, object> htmlAttributes)
        {
            string fullName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(name);

            TagBuilder dropdown = new TagBuilder("select");

            dropdown.Attributes.Add("name", fullName);
            dropdown.MergeAttributes(htmlAttributes);
            dropdown.MergeAttributes(htmlHelper.GetUnobtrusiveValidationAttributes(name, metadata));

            StringBuilder options = new StringBuilder();

            if (optionLabel != null)
            {
                options.Append("<option value='" + String.Empty + "'>" + optionLabel + "</option>");
            }

            foreach (var item in list)
            {
                if (item.Selected == true)
                {
                    options.Append("<option value='" + item.Value + "' selected>" + item.Text + "</option>");
                }
                else
                {
                    options.Append("<option value='" + item.Value + "'>" + item.Text + "</option>");
                }
            }
            dropdown.InnerHtml = options.ToString();
            return(MvcHtmlString.Create(dropdown.ToString(TagRenderMode.Normal)));
        }
Example #22
0
        public static MvcHtmlString RadioButtonListFor <TModel, TProperty>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TProperty> > expression, bool isInline, IDictionary <string, object> htmlAttributes = null)
        {
            ModelMetadata metadata   = ModelMetadata.FromLambdaExpression <TModel, TProperty>(expression, htmlHelper.ViewData);
            var           dataSource = TermDescription.GetDataFor(metadata.PropertyName);

            string name       = ExpressionHelper.GetExpressionText(expression);
            var    attributes = htmlHelper.GetUnobtrusiveValidationAttributes(name, metadata);

            if (htmlAttributes == null)
            {
                htmlAttributes = attributes;
            }
            else
            {
                foreach (var item in attributes)
                {
                    htmlAttributes.Add(item);
                }
            }

            string fullHtmlFieldName = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(name);
            string stateValue        = (string)GetModelStateValue(htmlHelper, fullHtmlFieldName, typeof(string));

            if (string.IsNullOrEmpty(stateValue))
            {
                if (metadata.Model != null)
                {
                    // 枚举值直接转换成整数,然后转成字符串
                    stateValue = ((int)metadata.Model).ToString();
                }
            }

            return(GenerateHtml(fullHtmlFieldName, dataSource, isInline, htmlAttributes, stateValue));
        }
        private static MvcHtmlString InputHelper(HtmlHelper htmlHelper, string kInputType, ModelMetadata metadata, string name, object value, bool setId, IDictionary <string, object> htmlAttributes)
        {
            string     fullName   = htmlHelper.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(name);
            TagBuilder tagBuilder = new TagBuilder("input");

            tagBuilder.MergeAttributes(htmlAttributes);
            if (kInputType != null)
            {
                tagBuilder.MergeAttribute("type", kInputType, true);
            }
            tagBuilder.MergeAttribute("name", fullName, true);
            tagBuilder.GenerateId(fullName);

            ModelState modelState;

            if (htmlHelper.ViewData.ModelState.TryGetValue(fullName, out modelState))
            {
                if (modelState.Errors.Count > 0)
                {
                    tagBuilder.AddCssClass(HtmlHelper.ValidationInputCssClassName);
                }
            }

            tagBuilder.MergeAttributes(htmlHelper.GetUnobtrusiveValidationAttributes(name, metadata));

            return(new MvcHtmlString(tagBuilder.ToString(TagRenderMode.SelfClosing)));
        }
        public static MvcHtmlString ReadOnlyTextFor <TModel, TValue>(this HtmlHelper <TModel> html, System.Linq.Expressions.Expression <Func <TModel, TValue> > expression)
        {
            string        name     = ExpressionHelper.GetExpressionText(expression);
            ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
            string        fullName = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(name);
            var           value    = metadata.Model == null
                    ? ""
                    : string.IsNullOrEmpty(metadata.DisplayFormatString)
                        ? metadata.Model.ToString()
                        : string.Format(metadata.DisplayFormatString, metadata.Model);
            TagBuilder tag;

            if (metadata.DataTypeName == "MultilineText")
            {
                tag = new TagBuilder("textarea");
                tag.GenerateId(fullName);
                tag.Attributes.Add("name", fullName);
                tag.Attributes.Add("readonly", "readonly");
                tag.InnerHtml = value;
            }
            else
            {
                tag = new TagBuilder("input");
                tag.GenerateId(fullName);
                tag.Attributes.Add("name", fullName);
                tag.Attributes.Add("type", "text");
                tag.Attributes.Add("readonly", "readonly");
                tag.Attributes.Add("value", value);
            }
            tag.MergeAttributes(html.GetUnobtrusiveValidationAttributes(name, metadata));
            return(MvcHtmlString.Create(tag.ToString(TagRenderMode.Normal)));
        }
Example #25
0
        public static MvcHtmlString CheckBoxListFor <TModel, T>
            (this HtmlHelper <TModel> htmlHelper,
            Expression <Func <TModel, IEnumerable <T> > > selectedValuesExpression,
            Expression <Func <TModel, Dictionary <string, T> > > listOfOptionsExpression = null,
            string ulClass = null)
        {
            ModelMetadata metadataselectedValues = ModelMetadata.FromLambdaExpression(selectedValuesExpression, htmlHelper.ViewData);

            var unobtrusiveValidationAttributes = htmlHelper.GetUnobtrusiveValidationAttributes
                                                      (metadataselectedValues.PropertyName, metadataselectedValues);

            var html = new TagBuilder("ul");

            if (!String.IsNullOrEmpty(ulClass))
            {
                html.MergeAttribute("class", ulClass);
            }

            string innerhtml      = "";
            var    selectedValues = metadataselectedValues.Model as IEnumerable <T>;
            Dictionary <string, T> listOfOptions = null;

            if (typeof(T).BaseType != typeof(Enum) && listOfOptions == null)
            {
                throw new Exception("please provide list of possible checkboxes");
            }
            //check if is enum and we don't have any list
            else if (typeof(T).BaseType == typeof(Enum) && listOfOptions == null)
            {
                listOfOptions = new Dictionary <string, T>();
                listOfOptions = Enum.GetValues(typeof(T)).Cast <T>().ToDictionary(currentItem => Enum.GetName(typeof(T), currentItem));
            }
            else
            {
                ModelMetadata metadatalistOfOptions = ModelMetadata.FromLambdaExpression(listOfOptionsExpression, htmlHelper.ViewData);
                listOfOptions = metadatalistOfOptions.Model as Dictionary <string, T>;
            }
            foreach (var item in listOfOptions)
            {
                bool ischecked = (selectedValues == null) ? false : selectedValues.Any(x => x.ToString() == item.Value.ToString());
                var  itemId    = metadataselectedValues.PropertyName + "_" + item.Value;
                var  liBuilder = new TagBuilder("li");

                var inputBuilder = new TagBuilder("input");
                inputBuilder.MergeAttribute("type", "checkbox");
                inputBuilder.MergeAttribute("name", metadataselectedValues.PropertyName, true);
                inputBuilder.MergeAttribute("id", itemId, true);
                inputBuilder.MergeAttribute("value", item.Value.ToString(), true);
                inputBuilder.MergeAttributes(unobtrusiveValidationAttributes);
                if (ischecked)
                {
                    inputBuilder.MergeAttribute("checked", "'checked'");
                }

                liBuilder.InnerHtml = inputBuilder.ToString() + htmlHelper.Label(itemId, item.Key);
                innerhtml           = innerhtml + liBuilder;
            }
            html.InnerHtml = innerhtml;
            return(new MvcHtmlString(html.ToString()));
        }
        public static string RenderTextArea(HtmlHelper html, BootstrapTextAreaModel model)
        {
            if (model == null || string.IsNullOrEmpty(model.htmlFieldName))
            {
                return(null);
            }

            string validationMessage = "";

            if (model.displayValidationMessage)
            {
                string validation = html.ValidationMessage(model.htmlFieldName).ToHtmlString();
                validationMessage = new BootstrapHelpText(validation, model.validationMessageStyle).ToHtmlString();
            }
            model.htmlAttributes.MergeHtmlAttributes(html.GetUnobtrusiveValidationAttributes(model.htmlFieldName, model.metadata));
            if (!string.IsNullOrEmpty(model.id))
            {
                model.htmlAttributes.AddOrReplace("id", model.id);
            }
            if (model.tooltipConfiguration != null)
            {
                model.htmlAttributes.MergeHtmlAttributes(model.tooltipConfiguration.ToDictionary());
            }
            return(html.TextArea(model.htmlFieldName, model.value, model.rows, model.columns, model.htmlAttributes.FormatHtmlAttributes()).ToHtmlString() + validationMessage);
        }
Example #27
0
        public static MvcHtmlString SemanticTextDateFor <TModel, TProperty>(this HtmlHelper <TModel> html, Expression <Func <TModel, TProperty> > expression, dynamic htmlAttributes)
        {
            var fullBindingName = html.ViewContext.ViewData.TemplateInfo.GetFullHtmlFieldName(ExpressionHelper.GetExpressionText(expression));
            var metadata        = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
            var validations     = html.GetUnobtrusiveValidationAttributes(metadata.PropertyName, metadata);
            var tag             = new TagBuilder("input");

            InsertValidateAttribute(tag, validations);

            if (htmlAttributes != null)
            {
                tag.MergeAttributes(HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
            }

            tag.Attributes.Add("type", "text");
            tag.Attributes.Add("id", TagBuilder.CreateSanitizedId(fullBindingName));
            tag.Attributes.Add("name", fullBindingName);
            tag.Attributes.Add("data-gtmask", "datetime");

            var valorInput = metadata.Model?.ToString();

            if (string.IsNullOrWhiteSpace(valorInput))
            {
                tag.Attributes.Add("value", string.Empty);
            }
            else
            {
                tag.Attributes.Add("value", DateTime.Parse(valorInput) != DateTime.MinValue ? Convert.ToDateTime(valorInput).ToShortDateString() : string.Empty);
            }

            return(new MvcHtmlString(tag.ToString(TagRenderMode.SelfClosing)));
        }
Example #28
0
        private static string InputTagHelper(HtmlHelper htmlHelper, ModelMetadata metadata, InputType inputType, string expression, IDictionary <string, object> htmlAttributes, string fullName, int index, string fieldType, string val)
        {
            var tagBuilder = new TagBuilder("input");

            tagBuilder.MergeAttributes(htmlAttributes);
            tagBuilder.MergeAttribute("type", HtmlHelper.GetInputTypeString(inputType));
            tagBuilder.MergeAttribute("name", $"{fullName}[{index}].{fieldType}", true);
            tagBuilder.MergeAttribute("value", val);

            tagBuilder.GenerateId($"{fullName}_{index}_{fieldType}");

            ModelState modelState;

            if (htmlHelper.ViewData.ModelState.TryGetValue(fullName, out modelState))
            {
                if (modelState.Errors.Count > 0)
                {
                    tagBuilder.AddCssClass(HtmlHelper.ValidationInputCssClassName);
                }
            }

            if (metadata != null)
            {
                tagBuilder.MergeAttributes(htmlHelper.GetUnobtrusiveValidationAttributes(expression, metadata));
            }

            return(tagBuilder.ToString(TagRenderMode.SelfClosing));
        }
Example #29
0
        public void GetUnobtrusiveValidationAttributesWithTwoClientRules()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock <ViewContext>();

            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper        = new HtmlHelper(viewContext.Object, viewDataContainer);

            htmlHelper.ClientValidationRuleFactory = delegate {
                ModelClientValidationRule rule1 = new ModelClientValidationRule {
                    ValidationType = "type", ErrorMessage = "error"
                };
                rule1.ValidationParameters["foo"] = "bar";
                rule1.ValidationParameters["baz"] = "biff";
                ModelClientValidationRule rule2 = new ModelClientValidationRule {
                    ValidationType = "othertype", ErrorMessage = "othererror"
                };
                rule2.ValidationParameters["true3"] = "false4";
                return(new[] { rule1, rule2 });
            };

            // Act
            IDictionary <string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.AreEqual("error", result["data-val-type"]);
            Assert.AreEqual("bar", result["data-val-type-foo"]);
            Assert.AreEqual("biff", result["data-val-type-baz"]);
            Assert.AreEqual("othererror", result["data-val-othertype"]);
            Assert.AreEqual("false4", result["data-val-othertype-true3"]);
        }
        /// <summary>
        /// Create drop down menu item for property
        /// selected by expression using provided list item.
        /// </summary>
        /// <typeparam name="TModel">Type of model.</typeparam>
        /// <typeparam name="TProperty">Type of property.</typeparam>
        /// <param name="htmlHelper">HtmlHelper.</param>
        /// <param name="expression">Expression to select needed property.</param>
        /// <param name="listItem">List item to get text and value.</param>
        /// <returns>List item with radio button and span.</returns>
        internal static FluentTagBuilder CreateDropDownButtonMenuItem <TModel, TProperty>(
            this HtmlHelper <TModel> htmlHelper,
            Expression <Func <TModel, TProperty> > expression,
            SelectListItem listItem)
        {
            FluentTagBuilder menuItem = new FluentTagBuilder("li");

            // Initialize span
            FluentTagBuilder span = new FluentTagBuilder("span")
                                    .SetInnerText(listItem.Text);

            // Initialize radio button
            string        fieldName = ExpressionHelper.GetExpressionText(expression);
            ModelMetadata metadata  = ModelMetadata.FromLambdaExpression(
                expression, htmlHelper.ViewData);

            // Get validation attributes and add hidden attribute
            var htmlAttributes = htmlHelper
                                 .GetUnobtrusiveValidationAttributes(fieldName);

            htmlAttributes.Add("hidden", "hidden");

            MvcHtmlString radioButton = htmlHelper
                                        .RadioButton(fieldName, listItem.Value, listItem.Selected, htmlAttributes);

            // Set content of list menu item
            menuItem.AppendChild(span).AppendChild(radioButton);

            return(menuItem);
        }
Example #31
0
        public void GetUnobtrusiveValidationAttributeUsesViewDataForModelMetadataLookup()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            var viewData = new ViewDataDictionary<MyModel>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            var viewDataContainer = MvcHelper.GetViewDataContainer(viewData);
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("MyProperty");

            // Assert
            Assert.Equal(2, result.Count);
            Assert.Equal("true", result["data-val"]);
            Assert.Equal("My required message", result["data-val-required"]);
        }
Example #32
0
        public void GetUnobtrusiveValidationAttributesMarksRenderedFieldsWithFullName()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            var viewData = new ViewDataDictionary();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            var viewDataContainer = MvcHelper.GetViewDataContainer(viewData);
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);

            // Act
            htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.False(formContext.RenderedField("foobar"));
            Assert.True(formContext.RenderedField("Prefix.foobar"));
        }
Example #33
0
        public void GetUnobtrusiveValidationAttributesWithTwoClientRules()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);
            htmlHelper.ClientValidationRuleFactory = delegate
            {
                ModelClientValidationRule rule1 = new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "error" };
                rule1.ValidationParameters["foo"] = "bar";
                rule1.ValidationParameters["baz"] = "biff";
                ModelClientValidationRule rule2 = new ModelClientValidationRule { ValidationType = "othertype", ErrorMessage = "othererror" };
                rule2.ValidationParameters["true3"] = "false4";
                return new[] { rule1, rule2 };
            };

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Equal("error", result["data-val-type"]);
            Assert.Equal("bar", result["data-val-type-foo"]);
            Assert.Equal("biff", result["data-val-type-baz"]);
            Assert.Equal("othererror", result["data-val-othertype"]);
            Assert.Equal("false4", result["data-val-othertype-true3"]);
        }
Example #34
0
        public void GetUnobtrusiveValidationAttributesUsesShortNameForModelMetadataLookup()
        {
            // Arrange
            string passedName = null;
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            var viewData = new ViewDataDictionary();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            viewData.TemplateInfo.HtmlFieldPrefix = "Prefix";
            var viewDataContainer = MvcHelper.GetViewDataContainer(viewData);
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);
            htmlHelper.ClientValidationRuleFactory = (name, _) =>
            {
                passedName = name;
                return Enumerable.Empty<ModelClientValidationRule>();
            };

            // Act
            htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Equal("foobar", passedName);
        }
Example #35
0
        public void GetUnobtrusiveValidationAttributesMessageIsNotHtmlEncoded()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);
            htmlHelper.ClientValidationRuleFactory = delegate { return new[] { new ModelClientValidationRule { ValidationType = "type", ErrorMessage = "<script>alert('xss')</script>" } }; };

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Equal("<script>alert('xss')</script>", result["data-val-type"]);
        }
Example #36
0
        public void GetUnobtrusiveValidationAttributesIncludesDataValTrueWithNonEmptyClientRuleList()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);
            htmlHelper.ClientValidationRuleFactory = delegate { return new[] { new ModelClientValidationRule { ValidationType = "type" } }; };

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Equal("true", result["data-val"]);
        }
Example #37
0
        public void GetUnobtrusiveValidationAttributesReturnsEmptySetAndSetsFieldAsRenderedForFieldWithNoClientRules()
        {
            // Arrange
            var formContext = new FormContext();
            var viewContext = new Mock<ViewContext>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);
            htmlHelper.ClientValidationRuleFactory = delegate { return Enumerable.Empty<ModelClientValidationRule>(); };

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Empty(result);
            Assert.True(formContext.RenderedField("foobar"));
        }
Example #38
0
        public void GetUnobtrusiveValidationAttributesReturnsEmptySetWhenFieldHasAlreadyBeenRendered()
        {
            // Arrange
            var formContext = new FormContext();
            formContext.RenderedField("foobar", true);
            var viewContext = new Mock<ViewContext>();
            viewContext.SetupGet(vc => vc.FormContext).Returns(formContext);
            viewContext.SetupGet(vc => vc.ClientValidationEnabled).Returns(true);
            viewContext.SetupGet(vc => vc.UnobtrusiveJavaScriptEnabled).Returns(true);
            var viewDataContainer = MvcHelper.GetViewDataContainer(new ViewDataDictionary());
            var htmlHelper = new HtmlHelper(viewContext.Object, viewDataContainer);

            // Act
            IDictionary<string, object> result = htmlHelper.GetUnobtrusiveValidationAttributes("foobar");

            // Assert
            Assert.Empty(result);
        }
Example #39
0
        // Helpers

        private static void AssertBadClientValidationRule(HtmlHelper htmlHelper, string expectedMessage, params ModelClientValidationRule[] rules)
        {
            htmlHelper.ClientValidationRuleFactory = delegate { return rules; };
            Assert.Throws<InvalidOperationException>(
                () => htmlHelper.GetUnobtrusiveValidationAttributes(Guid.NewGuid().ToString()),
                expectedMessage
                );
        }