public static MvcHtmlString DropDownListMultipleChoiceFor <TModel, TValue>(this HtmlHelper <TModel> helper,
Expression <Func <TModel, TValue> > expression,
IEnumerable <SelectListItem> list, string label = "", object htmlAttributes = null)
{
var attributes = new Dictionary <string, object>();
if (htmlAttributes != null)
{
foreach (var property in htmlAttributes.GetType().GetProperties())
{
attributes[property.Name] = property.GetValue(htmlAttributes);
}
}
var numMaxEl = HelperExtensions.NumMaxEl;
attributes["data-live-search"] = (list.Count() > numMaxEl) ? "true" : "false";
attributes["data-actions-box"] = "true";
attributes["data-size"] = "10";
attributes["multiple"] = "multiple";
attributes["data-select-all-Text"] = "Select All";
attributes["data-deselect-all-Text"] = "Deselect All";
attributes["data-none-selected-Text"] = "Select...";
attributes["class"] = (
attributes.ContainsKey("class") ?
attributes["class"] as string :
""
) + " selectpicker";
return(SelectExtensions.ListBoxFor(helper, expression, list, attributes));
}
/// <summary>
/// Return the Html's select element
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <typeparam name="TProperty"></typeparam>
/// <param name="htmlHelper"></param>
/// <param name="expression"></param>
/// <param name="selectList"></param>
/// <param name="htmlAttributes"></param>
/// <param name="addEmptyRow"></param>
/// <returns></returns>
public static MvcHtmlString DropDownListFor <TModel, TProperty>(
this HtmlHelper <TModel> htmlHelper,
Expression <Func <TModel, TProperty> > expression,
IEnumerable <SelectListItem> selectList,
object htmlAttributes,
bool addEmptyRow)
{
var list = new List <SelectListItem>();
if (addEmptyRow)
{
list.Add(new SelectListItem()
{
Value = string.Empty,
Text = "選択してください"
});
}
if (selectList != null)
{
list.AddRange(selectList);
}
return(SelectExtensions.DropDownListFor(
htmlHelper,
expression,
list,
htmlAttributes
));
}
/// <summary>
/// Drop down list
/// </summary>
/// <typeparam name="TModel">TModel entity</typeparam>
/// <typeparam name="TValue">TValue entity</typeparam>
/// <param name="htmlHelper">html helper</param>
/// <param name="expression">Expression field</param>
/// <param name="selectList">Select list</param>
/// <param name="htmlAttributes">html attributes</param>
/// <param name="disabled">Disabled field</param>
/// <returns>returns mvc html string</returns>
public static MvcHtmlString DropDownListFor <TModel, TValue>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TValue> > expression, IEnumerable <SelectListItem> selectList, object htmlAttributes, string disabled)
{
Func <TModel, TValue> deleg = expression.Compile();
var result = deleg(htmlHelper.ViewData.Model);
if (string.IsNullOrEmpty(disabled))
{
return(SelectExtensions.DropDownListFor(htmlHelper, expression, selectList, htmlAttributes));
}
else
{
string name = ExpressionHelper.GetExpressionText(expression);
string selectedText = SelectInternal(htmlHelper, name, selectList);
RouteValueDictionary routeValues = new RouteValueDictionary(htmlAttributes);
if (disabled == "disabled")
{
routeValues.Add("disabled", "disabled");
}
else if (disabled == "readonly")
{
routeValues.Add("readonly", "read-only");
}
return(InputExtensions.TextBox(htmlHelper, name, selectedText, routeValues));
}
}
//https://jeremylindsayni.wordpress.com/2015/01/17/mvc-enhanced-dropdownlistfor-part-2/
/// <summary>
/// Returns a single-selection HTML <select> element for the expression <paramref name="name" />,
/// using the specified list items.
/// </summary>
/// <typeparam name="TModel">The type of the model.</typeparam>
/// <typeparam name="TListItemType">The type of the items in the list.</typeparam>
/// <typeparam name="TItemId">The type of the item identifier.</typeparam>
/// <typeparam name="TItemName">The type of the item name.</typeparam>
/// <typeparam name="TSelectedValue">The type of the selected value expression result.</typeparam>
/// <param name="htmlHelper">The HTML helper instance that this method extends.</param>
/// <param name="formFieldName">Name of the form field.</param>
/// <param name="items">The items to put in the HTML <select> element.</param>
/// <param name="optionValueProperty">The item identifier property.</param>
/// <param name="optionInnerHTMLProperty">The item name property.</param>
/// <param name="optionLabel">The text for a default empty item. Does not include such an item if argument is <c>null</c>.</param>
/// <param name="htmlAttributes">An <see cref="object" /> that contains the HTML attributes for the <select> element. Alternatively, an
/// <see cref="IDictionary{string, object}" /> instance containing the HTML attributes.</param>
/// <returns>A new MvcHtmlString containing the <select> element.</returns>
public static MvcHtmlString AutoDropDownListFor <TModel, TListItemType, TItemId, TItemName, TSelectedValue>(
this HtmlHelper <TModel> htmlHelper,
Expression <Func <TModel, TSelectedValue> > formFieldName,
Expression <Func <TModel, List <TListItemType> > > items,
Expression <Func <TListItemType, TItemId> > optionValueProperty,
Expression <Func <TListItemType, TItemName> > optionInnerHTMLProperty,
string optionLabel = null,
object htmlAttributes = null)
{
var formField = ExpressionHelper.GetExpressionText(formFieldName);
var itemIdPropertyName = ExpressionHelper.GetExpressionText(optionValueProperty);
var itemNamePropertyName = ExpressionHelper.GetExpressionText(optionInnerHTMLProperty);
var listItemsModel = GetModelFromExpressionAndViewData(items, htmlHelper.ViewData) as List <TListItemType>;
// if the list is null, initialize to an empty list so we display something
if (listItemsModel == null)
{
listItemsModel = new List <TListItemType>();
}
var selectedValueObject = GetModelFromExpressionAndViewData(formFieldName, htmlHelper.ViewData);
var selectList = new SelectList(listItemsModel, itemIdPropertyName, itemNamePropertyName, selectedValueObject);
return(SelectExtensions.DropDownList(htmlHelper: htmlHelper, name: formField, selectList: selectList, optionLabel: optionLabel, htmlAttributes: htmlAttributes));
}
public static MvcHtmlString DropDownListFor <TModel, TListItemType, TItemId, TItemName, TSelectedValue>(
this HtmlHelper <TModel> htmlHelper,
Expression <Func <TModel, TSelectedValue> > formFieldName,
Expression <Func <TModel, ICollection <TListItemType> > > items,
Expression <Func <TListItemType, TItemId> > optionValueProperty,
Expression <Func <TListItemType, TItemName> > optionInnerHtmlProperty,
[Optional] string optionLabel,
[Optional] object htmlAttributes)
{
if (htmlHelper == null)
{
throw new ArgumentNullException(paramName: "htmlHelper", message: "The static Html Helper is null.");
}
var formField = ExpressionHelper.GetExpressionText(formFieldName);
var itemIdPropertyName = ExpressionHelper.GetExpressionText(optionValueProperty);
var itemNamePropertyName = ExpressionHelper.GetExpressionText(optionInnerHtmlProperty);
var listItemsModel = GetModelFromExpressionAndViewData(items, htmlHelper.ViewData) as List <TListItemType>;
// if the list is null, initialize to an empty list so we display something
if (listItemsModel == null)
{
listItemsModel = new List <TListItemType>();
}
var selectedValueObject = GetModelFromExpressionAndViewData(formFieldName, htmlHelper.ViewData);
var selectList = new SelectList(listItemsModel, itemIdPropertyName, itemNamePropertyName, selectedValueObject);
return(SelectExtensions.DropDownList(htmlHelper: htmlHelper, name: formField, selectList: selectList, optionLabel: optionLabel, htmlAttributes: htmlAttributes));
}
public static MvcHtmlString DropDownListBind(this HtmlHelper htmlHelper, string name, IEnumerable <SelectListItem> selectList, string optionLabel, object htmlAttributes)
{
var bind = new KnockoutBind(null, htmlAttributes);
bind.AddBind("value", name);
return(SelectExtensions.DropDownList(htmlHelper, name, selectList, optionLabel, bind));
}
public static MvcHtmlString DropDownListFor <TModel, TProperty>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TProperty> > expression, object htmlAttributes)
{
if (expression.NodeType != ExpressionType.Lambda || expression.Body.NodeType != ExpressionType.MemberAccess)
{
throw new ArgumentException("Cannot determine dropdown list items - unparsable expression");
}
var memberExpression = expression.Body as MemberExpression;
var attributes = (ListChoiceAttribute[])memberExpression.Member.GetCustomAttributes(typeof(ListChoiceAttribute), true);
if (attributes == null || attributes.Length == 0)
{
throw new ArgumentException("Cannot determine dropdown list items - no ListChoiceAttribute");
}
// get the object whose member is being accessed by executing the expressions' "base"
var lambda = Expression.Lambda(memberExpression.Expression, expression.Parameters);
var containingObject = lambda.Compile().DynamicInvoke(htmlHelper.ViewData.Model);
// finally, get the value of the property
string propertyName = attributes.First().ListPropertyName;
Type declaringType = (expression.Body as MemberExpression).Member.DeclaringType;
object value = declaringType.GetProperty(propertyName).GetValue(containingObject, null);
if (!value.GetType().GetInterfaces().Any(x => x == typeof(IEnumerable <SelectListItem>)))
{
throw new ArgumentException("Cannot determine dropdown list items - invalid list property specified");
}
// do not call on htmlHelper to avoid a stack overflow: apparantly (IEnumerable<SelectListItem>value) is seen as object and we're called again
return(SelectExtensions.DropDownListFor(htmlHelper, expression, (IEnumerable <SelectListItem>)value, htmlAttributes));
}
public static MvcHtmlString DropDownListFor <TModel, TProperty>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TProperty> > expression, object htmlAttributes)
{
if (expression.NodeType != ExpressionType.Lambda || expression.Body.NodeType != ExpressionType.MemberAccess)
{
throw new ArgumentException("Cannot determine dropdown list items - unparsable expression");
}
MemberInfo member = (expression.Body as MemberExpression).Member;
var attributes = (ListChoiceAttribute[])member.GetCustomAttributes(typeof(ListChoiceAttribute), true);
if (attributes == null || attributes.Length == 0)
{
throw new ArgumentException("Cannot determine dropdown list items - no ListChoiceAttribute");
}
string propertyName = attributes.First().ListPropertyName;
PropertyInfo property = htmlHelper.ViewData.Model.GetType().GetProperty(propertyName);
object value = property.GetValue(htmlHelper.ViewData.Model, null);
if (!value.GetType().GetInterfaces().Any(x => x == typeof(IEnumerable <SelectListItem>)))
{
throw new ArgumentException("Cannot determine dropdown list items - invalid list property specified");
}
// do not call on htmlHelper to avoid a stack overflow: apparantly (IEnumerable<SelectListItem>value) is seen as object and we're called again
return(SelectExtensions.DropDownListFor(htmlHelper, expression, (IEnumerable <SelectListItem>)value, htmlAttributes));
}
public static MvcHtmlString DropDownListFor <TModel, TProperty, TEnum>(
this HtmlHelper <TModel> htmlHelper,
Expression <Func <TModel, TProperty> > expression,
TEnum?selectedValue,
Func <TEnum, string> getValue,
List <SelectListItem> headerItems = null) where TEnum : struct
{
IEnumerable <TEnum> values = Enum.GetValues(typeof(TEnum))
.Cast <TEnum>();
IEnumerable <SelectListItem> items = from value in values
select new SelectListItem()
{
Text = value.ToString(),
Value = getValue(value),
Selected = (value.Equals(selectedValue))
};
if (headerItems != null && headerItems.Count > 0)
{
foreach (var item in headerItems)
{
item.Selected = item.Value.Equals(selectedValue);
}
//headerItems.Union(items);
headerItems.AddRange(items);
}
return(SelectExtensions.DropDownListFor(htmlHelper, expression, headerItems));
}
public void RightJoin_adds_join()
{
Select <TestClass> select = new Select <TestClass>();
SelectExtensions.RightJoin(select, "foo", "1=1");
select.Join().Sql().MustBe("right join foo on 1=1");
}
public void Join_adds_join()
{
Select <TestClass> select = new Select <TestClass>();
SelectExtensions.Join(select, JoinType.Left, "foo", "1=1");
select.Join().Sql().MustBe("left join foo on 1=1");
}
public static MvcHtmlString DropDownList(this HtmlHelper helper, string name, Type type, object selectedValue, object htmlAttributes)
{
if (!type.IsEnum)
{
throw new ArgumentException("Invalid type. It should be an enum.");
}
if (selectedValue == null || selectedValue.GetType() != type)
{
throw new ArgumentException("Invalid selected value type. It should be '" + type.ToString() + "'");
}
var items = new List <SelectListItem>();
foreach (int value in Enum.GetValues(type))
{
string valueText = Enum.GetName(type, value);
if (!IsObsoleteValue(value, valueText, type))
{
var item = new SelectListItem();
item.Value = value.ToString();
item.Text = valueText;
item.Selected = object.Equals(value, (int)selectedValue);
items.Add(item);
}
}
return(SelectExtensions.DropDownList(helper, name, items, htmlAttributes));
}
public static MvcHtmlString TimeDropDownList(this HtmlHelper html, string name, object htmlAttributes, int selectedHr = 0)
{
var list = new SelectList(new[]
{
new { Key = "0", Value = "00:00" },
new { Key = "1", Value = "01:00" },
new { Key = "2", Value = "02:00" },
new { Key = "3", Value = "03:00" },
new { Key = "4", Value = "04:00" },
new { Key = "5", Value = "05:00" },
new { Key = "6", Value = "06:00" },
new { Key = "7", Value = "07:00" },
new { Key = "8", Value = "08:00" },
new { Key = "9", Value = "09:00" },
new { Key = "10", Value = "10:00" },
new { Key = "11", Value = "11:00" },
new { Key = "12", Value = "12:00" },
new { Key = "13", Value = "13:00" },
new { Key = "14", Value = "14:00" },
new { Key = "15", Value = "15:00" },
new { Key = "16", Value = "16:00" },
new { Key = "17", Value = "17:00" },
new { Key = "18", Value = "18:00" },
new { Key = "19", Value = "19:00" },
new { Key = "20", Value = "20:00" },
new { Key = "21", Value = "21:00" },
new { Key = "22", Value = "22:00" },
new { Key = "23", Value = "23:00" },
new { Key = "24", Value = "24:00" },
}, "Key", "Value", selectedHr);
return(SelectExtensions.DropDownList(html, name, list, htmlAttributes));
}
public static MvcHtmlString DropDownListBindFor <TModel, TProperty>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TProperty> > expression, IEnumerable <SelectListItem> selectList, string optionLabel, object htmlAttributes)
{
var bind = new KnockoutBind(null, htmlAttributes);
bind.AddBind("value", ExpressionHelper.GetExpressionText(expression));
return(SelectExtensions.DropDownListFor(htmlHelper, expression, selectList, optionLabel, bind));
}
public static void DropDownListForTestWithListAndNoSelectedItem()
{
// Arrange
var userViewModel = new UserViewModel(new List <User>()
{
new User {
Name = "Dave", Id = 1
},
new User {
Name = "Nate", Id = 2
},
new User {
Name = "Pat", Id = 3
},
new User {
Name = "Taylor", Id = 4
},
new User {
Name = "Chris", Id = 5
}
});
var htmlHelper = HtmlHelperMock.GetMock(userViewModel);
var expectedMvcHtmlString = SelectExtensions.DropDownListFor(htmlHelper, m => m.UserId, new SelectList(userViewModel.UserNames, "Id", "Name", userViewModel.UserId));
// Act
var actualMvcHtmlString = HtmlHelperSelectExtensions.DropDownListFor(htmlHelper, m => m.UserId, m => m.UserNames, m => m.Id, m => m.Name);
// Assert
Assert.AreEqual(expectedMvcHtmlString.ToHtmlString(), actualMvcHtmlString.ToHtmlString());
}
public static MvcHtmlString UomEnumDropdownList <TModel, TEnum>(
this HtmlHelper <TModel> htmlHelper, string name, TEnum selectedValue, object htmlAttributes) where TEnum : struct
{
var values = Enum.GetValues(typeof(TEnum)).Cast <TEnum>();
IEnumerable <SelectListItem> items = ValueToListItems(selectedValue, values);
return(SelectExtensions.DropDownList(htmlHelper, name, items, htmlAttributes));
}
public static MvcHtmlString KODropDownListFor <TModel, TProperty>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TProperty> > expression, IEnumerable <SelectListItem> selectList, string optionLabel)
{
var htmlAttributes = new Dictionary <string, object>();
var name = GetMemberName(expression);
htmlAttributes.Add("data-bind", string.Format("value:{0}", name));
return(SelectExtensions.DropDownListFor(htmlHelper, expression, selectList, optionLabel, htmlAttributes));
}
public static MvcHtmlString ListBoxFor <TModel, TProperty>(this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TProperty> > expression, IEnumerable <SelectListItem> selectList = null, string cssClass = null, string dir = null, bool disabled = false, string id = null, string lang = null, int?size = null, string style = null, int?tabIndex = null, string title = null)
{
return(SelectExtensions.ListBoxFor(
htmlHelper,
expression,
selectList,
SelectAttributes(cssClass, dir, disabled, id, lang, size, style, tabIndex, title)
));
}
public static MvcHtmlString ListBox(this HtmlHelper htmlHelper, string name, IEnumerable <SelectListItem> selectList = null, string cssClass = null, string dir = null, bool disabled = false, string id = null, string lang = null, int?size = null, string style = null, int?tabIndex = null, string title = null)
{
return(SelectExtensions.ListBox(
htmlHelper,
name,
selectList,
SelectAttributes(cssClass, dir, disabled, id, lang, size, style, tabIndex, title)
));
}
public static MvcHtmlString Ul <T>(this HtmlHelper helper, string id, string cssClass, string alternateText, object htmlAttributes, string itemCssClass, IList <T> items, Func <T, IHtmlString> itemContent)
{
// // Create tag builder
// var imgTag = new TagBuilder("img");
//
// // Create valid id
// imgTag.GenerateId(id);
//
// // Add attributes
// imgTag.MergeAttribute("src", helper.Url().Content(src));
// imgTag.MergeAttribute("alt", helper.Encode(alternateText));
// imgTag.MergeAttributes(new RouteValueDictionary(htmlAttributes), true);
//
// // Render tag
// return new MvcHtmlString(imgTag.ToString(TagRenderMode.Normal));
SelectExtensions.DropDownList()
helper.DropDownList().
var ulTag = new TagBuilder("ul");
ulTag.GenerateId(id);
ulTag.AddCssClass(cssClass);
ulTag.MergeAttributes(new RouteValueDictionary(htmlAttributes), true);
var itemNumber = 0;
foreach (T item in items)
{
itemNumber++;
var liTag = new TagBuilder("li");
liTag.AddCssClass(itemCssClass);
if (Menu.IsSelected(item))
{
liTag.AddCssClass(SelectedItemCssClass);
}
if (itemNumber == 1)
{
liTag.AddCssClass("first");
}
if (itemNumber == items.Count)
{
liTag.AddCssClass("last");
}
liTag.InnerHtml = itemContent(item).ToHtmlString();
//if (string.IsNullOrEmpty(item.ClientCallbackMethod))
//{
// liTag.InnerHtml = System.Web.Mvc.Html.LinkExtensions.ActionLink(Helper, item.Text, item.Url.ActionName, item.Url.ControllerName ?? string.Empty).ToHtmlString();
//}
//else
//{
// // see http://stackoverflow.com/questions/134845/href-tag-for-javascript-links-or-javascriptvoid0
// liTag.InnerHtml = string.Format("<a onclick=\"{1}\">{0}</a>", item.Text, item.ClientCallbackMethod);
//}
ulTag.InnerHtml += liTag.ToString();
}
return(MvcHtmlString.Create(ulTag.ToString(TagRenderMode.Normal)));
}
/// <summary>
/// Gets the DropDownList component for the Enum property.
/// </summary>
/// <typeparam name="T">The model</typeparam>
/// <typeparam name="U">The property</typeparam>
/// <param name="htmlHelper">The HtmlHelper</param>
/// <param name="expression">The expression for the property</param>
/// <param name="htmlAttributes">The next html attributes for the component</param>
/// <returns>The HTML string of the DropDownList with internationalized options</returns>
public static MvcHtmlString LocalizedDropDownListFor <T, U>(this HtmlHelper <T> htmlHelper, Expression <Func <T, U> > expression, object htmlAttributes = null)
{
ModelMetadata metadata = ModelMetadata.FromLambdaExpression(expression, htmlHelper.ViewData);
Type enumType = GetNonNullableModelType(metadata);
List <SelectListItem> selectListItem = CreateListItems <U>(typeof(T), Enum.GetValues(enumType).Cast <U>(), metadata);
return(SelectExtensions.DropDownListFor(htmlHelper, expression, selectListItem, htmlAttributes));
}
public void Where_adds_clause()
{
Select select = new Select();
SelectExtensions.Where(select, "foo", SqlOperator.LessThan, 2);
select.Parameters.Count().MustBe(1);
select.Parameters["@p0"].MustBe(2);
select.Where().Sql().MustBe("where foo<@p0");
}
public void Linq4_Customers_CustomersAndDateOfEntry()
{
var result = SelectExtensions.Linq4(DataSource.Customers).ToList();
Assert.That(() => result.Count, Is.EqualTo(DataSource.Customers.Count - 1));
foreach (var(customer, dateOfEntry) in result)
{
Assert.That(FindCustomerOrdersMinDate(customer), Is.EqualTo(dateOfEntry));
}
}
public static MvcHtmlString UomEnumDropdownList <TModel, TEnum>(
this HtmlHelper <TModel> htmlHelper, string name, TEnum?selectedValue, object htmlAttributes) where TEnum : struct
{
var stringified = selectedValue != null?selectedValue.Value.ToString() : null;
var values = new[] { "---" }.Concat(Enum.GetValues(typeof(TEnum)).Cast <TEnum>().Select(v => v.ToString()));
IEnumerable <SelectListItem> items = ValueToListItems(stringified, values);
return(SelectExtensions.DropDownList(htmlHelper, name, items, htmlAttributes));
}
public void Where_adds_equals_clause()
{
Select select = new Select();
SelectExtensions.Where(select, "foo", 2);
select.Parameters.Count().MustBe(1);
select.Parameters["@p0"].MustBe(2);
select.Where().Sql().MustBe("where foo=@p0");
}
public static MvcHtmlString EnumDropdownListFor <TModel, TProperty, TEnum>(
this HtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TProperty> > expression, TEnum?selectedValue) where TEnum : struct
{
var stringified = selectedValue != null?selectedValue.Value.ToString() : null;
var values = new[] { "All" }.Concat(Enum.GetValues(typeof(TEnum)).Cast <TEnum>().Select(v => v.ToString()));
IEnumerable <SelectListItem> items = ValueToListItems(stringified, values);
return(SelectExtensions.DropDownListFor(htmlHelper, expression, items));
}
public void Linq7_Customers_Returns5()
{
var expectedResult = new[]
{
new Linq7CategoryGroup
{
Category = "Beverages",
UnitsInStockGroup = new[]
{
new Linq7UnitsInStockGroup
{
UnitsInStock = 39,
Prices = new[] { 19.0000M },
},
new Linq7UnitsInStockGroup
{
UnitsInStock = 17,
Prices = new[] { 18.0000M },
},
},
},
new Linq7CategoryGroup
{
Category = "Condiments",
UnitsInStockGroup = new[]
{
new Linq7UnitsInStockGroup
{
UnitsInStock = 15,
Prices = new[] { 10.0000M, 40.0000M },
},
new Linq7UnitsInStockGroup
{
UnitsInStock = 13,
Prices = new[] { 30.0000M },
},
},
},
};
var result = SelectExtensions.Linq7(DataSource.Products);
foreach (var categoryGroup in result)
{
var expectedCategoryGroup = expectedResult.Single(_ => _.Category == categoryGroup.Category);
foreach (var unitInStockGroup in categoryGroup.UnitsInStockGroup)
{
var expectedUnitInStockGroup = expectedCategoryGroup
.UnitsInStockGroup.Single(_ => _.UnitsInStock == unitInStockGroup.UnitsInStock);
CollectionAssert.AreEqual(expectedUnitInStockGroup.Prices, unitInStockGroup.Prices);
}
}
}
public void Where_adds_clause_when_clauses_already_exist()
{
Select <TestClass> select = new Select <TestClass>();
select.Where(x => x.Id, 7);
SelectExtensions.Where(select, "foo", SqlOperator.LessThan, 2);
select.Parameters.Count().MustBe(2);
select.Parameters["@p0"].MustBe(7);
select.Parameters["@p1"].MustBe(2);
select.Where().Sql().MustBe("where (Id=@p0 And foo<@p1)");
}
public static MvcHtmlString DropDownListControlFor <TModel, TValue>(this HtmlHelper <TModel> html, Expression <Func <TModel, TValue> > expression, IEnumerable <SelectListItem> selectList, object inputHtmlAttributes)
{
var metaData = ModelMetadata.FromLambdaExpression(expression, html.ViewData);
var htmlFieldName = ExpressionHelper.GetExpressionText(expression);
return(ControlGroupExtension.Helper(
html,
metaData,
htmlFieldName,
SelectExtensions.DropDownListFor(html, expression, selectList, inputHtmlAttributes)
));
}
public static MvcHtmlString JQM_SelectMenu(this HtmlHelper htmlHelper, string name, string label, MultiSelectList values, string optionLabel = null, SelectMenuConfig config = null)
{
TagBuilder tagResult = new TagBuilder("div");
tagResult.MergeAttribute("class", "ui-field-contain");
if (config == null)
{
config = new SelectMenuConfig();
}
tagResult.InnerHtml += LabelExtensions.Label(htmlHelper, "", label).ToHtmlString();
tagResult.InnerHtml += SelectExtensions.DropDownList(htmlHelper, name, values, optionLabel, (config != null) ? config.GetAttributes() : null).ToHtmlString();
return(tagResult.ToHtml());
}