public MvcModelBinding(ParameterInfo parameter, ModelMetadata metadata, IModelBinder binder, IList <ValueProviderFactory> valueProviderFactories)
{
_parameter = parameter ?? throw new ArgumentNullException(nameof(parameter));
_metadata = metadata ?? throw new ArgumentNullException(nameof(metadata));
_binder = binder ?? throw new ArgumentNullException(nameof(binder));
_valueProviderFactories = valueProviderFactories ?? throw new ArgumentNullException(nameof(valueProviderFactories));
}
public static IHtmlContent Checkbox(this IHtmlHelper <dynamic> htmlHelper, string propertyName, object htmlAttributes = null)
{
IList <SelectListItem> items = GetSelectList(htmlHelper, propertyName);
Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata metadata = ExpressionMetadataProvider.FromStringExpression(propertyName, htmlHelper.ViewData, htmlHelper.MetadataProvider).Metadata;
Type propertyType = GetNonNullableModelType(metadata);
bool inline = false;
if (metadata.AdditionalValues.ContainsKey("ModelCheckboxOrRadioInline"))
{
inline = ((bool)metadata.AdditionalValues["ModelCheckboxOrRadioInline"]);
}
var sb = new StringBuilder();
if (propertyType != typeof(string) && (propertyType.GetInterfaces().Contains(typeof(IEnumerable))))
{
return(htmlHelper.ValueCheckboxList(propertyName, items, inline));
}
else
{
return(htmlHelper.ValueRadioList(propertyName, items, inline));
}
}
/// <inheritdoc />
/// <remarks>Does nothing if <see cref="DescriptionFor"/> is <c>null</c>.</remarks>
public override Task ProcessAsync(TagHelperContext context, TagHelperOutput output)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
if (output == null)
{
throw new ArgumentNullException(nameof(output));
}
Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata metadata = DescriptionFor.Metadata;
if (metadata == null)
{
throw new InvalidOperationException(string.Format("No provided metadata ({0})", DescriptionForAttributeName));
}
output.Attributes.SetAttribute("id", metadata.PropertyName + "-description");
if (!string.IsNullOrWhiteSpace(metadata.Description))
{
string content = String.Format("<i class=\"fas fa-exclamation-circle\" data-container=\"body\" data-toggle=\"popover\" data-trigger=\"hover\" data-placement=\"top\" data-html=\"true\" data-content=\"{0}\" aria-hidden=\"true\"></i>", metadata.Description);
output.Content.SetHtmlContent(content);
output.TagMode = TagMode.StartTagAndEndTag;
}
return(Task.CompletedTask);
}
public static IHtmlContent EnumDropDownListForStringValue <TModel, TEnum>(this IHtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TEnum> > expression, object htmlAttributes = null)
{
var modelExpressionProvider = htmlHelper.ViewContext.HttpContext.RequestServices.GetRequiredService <ModelExpressionProvider>();
var expressionText = modelExpressionProvider.GetExpressionText(expression);
var modelExpression = modelExpressionProvider.CreateModelExpression(htmlHelper.ViewData, expressionText);
var modelExplorer = modelExpression.ModelExplorer;
Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata metadata = modelExplorer.Metadata;
//.NET Core 2.2
//var modelExplorer = Microsoft.AspNetCore.Mvc.ViewFeatures.Internal.ExpressionMetadataProvider.FromLambdaExpression(expression, htmlHelper.ViewData, htmlHelper.MetadataProvider);
//Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata metadata = modelExplorer.Metadata;
Type enumType = GetNonNullableModelType(metadata);
Type baseEnumType = Enum.GetUnderlyingType(enumType);
var items = ToSelectList(enumType).ToList();
if (metadata.IsNullableValueType)
{
items.Insert(0, new SelectListItem {
Text = "", Value = ""
});
}
return(htmlHelper.DropDownListFor(expression, items, htmlAttributes));
}
private static Type GetNonNullableModelType(Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata modelMetadata)
{
Type realModelType = modelMetadata.ModelType;
Type underlyingType = Nullable.GetUnderlyingType(realModelType);
if (underlyingType != null)
{
realModelType = underlyingType;
}
return(realModelType);
}
public static string GetEisppRuleElement(this Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata model, string fieldPrefix)
{
if (!fieldPrefix.StartsWith("Data.Events[0]."))
{
fieldPrefix = "Data.Events[0]." + fieldPrefix.Replace("NewEventObj.", "");
}
fieldPrefix = model.GetEisppRulePath(fieldPrefix + ".");
if (fieldPrefix.EndsWith("."))
{
fieldPrefix = fieldPrefix.Substring(0, fieldPrefix.Length - 1);
}
return(fieldPrefix);
}
public static IHtmlContent DropDownList(this IHtmlHelper <dynamic> htmlHelper, string propertyName, object htmlAttributes = null)
{
IList <SelectListItem> items = GetSelectList(htmlHelper, propertyName);
Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata metadata = ExpressionMetadataProvider.FromStringExpression(propertyName, htmlHelper.ViewData, htmlHelper.MetadataProvider).Metadata;
Type propertyType = GetNonNullableModelType(metadata);
if (propertyType != typeof(string) && (propertyType.GetInterfaces().Contains(typeof(IEnumerable))))
{
return(htmlHelper.ListBox(propertyName, items, htmlAttributes));
}
else
{
return(htmlHelper.DropDownList(propertyName, items, htmlAttributes));
}
}
public static IHtmlContent CheckboxButtons(this IHtmlHelper <dynamic> htmlHelper, string propertyName, bool groupRadioButtons, object htmlAttributes = null, object labelCheckboxHtmlAttributes = null, object labelRadioHtmlAttributes = null)
{
IList <SelectListItem> items = GetSelectList(htmlHelper, propertyName);
Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata metadata = ExpressionMetadataProvider.FromStringExpression(propertyName, htmlHelper.ViewData, htmlHelper.MetadataProvider).Metadata;
Type propertyType = GetNonNullableModelType(metadata);
var sb = new StringBuilder();
if (propertyType != typeof(string) && (propertyType.GetInterfaces().Contains(typeof(IEnumerable))))
{
return(htmlHelper.ValueCheckboxButtonList(propertyName, items, htmlAttributes, labelCheckboxHtmlAttributes));
}
else
{
return(htmlHelper.ValueRadioButtonList(propertyName, items, groupRadioButtons, htmlAttributes, labelRadioHtmlAttributes));
}
}
public static IList <SelectListItem> GetSelectList(Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata metadata, Enum value)
{
if (metadata == null)
{
throw new NullReferenceException();
}
if (metadata.ModelType == null)
{
throw new Exception("Invalid model type");
}
if (!IsValidForEnumHelper(metadata))
{
throw new Exception("Invalid type");
}
return(GetSelectList(metadata.ModelType, value));
}
public static string GetEisppRulePath(this Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata model, string fieldPrefix)
{
try
{
for (int i = 0; i < 10; i++)
{
fieldPrefix = fieldPrefix.Replace(i.ToString(), "", StringComparison.InvariantCultureIgnoreCase);
}
fieldPrefix = fieldPrefix.Replace("[]", "", StringComparison.InvariantCultureIgnoreCase);
fieldPrefix = fieldPrefix.Replace("Data.Events.", "", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace("CriminalProceeding.", "NPR.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".Case.", ".DLO.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".Status.", ".DLOSTA.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".ConnectedCases.", ".DLOOSN.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".Persons.", ".FZL.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".Punishments.", ".NKZ.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".ProbationMeasure.", ".PBC.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".Crimes.", ".PNE.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".PersonCPStatus.", ".NPRFZLSTA.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".CrimeStatus.", ".PNESTA.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".CPPersonCrimes.", ".NPRFZLPNE.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".CrimeSanction.", ".SCQ.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".Measures.", ".MPP.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".BirthPlace.", ".MRD.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace("EisppSrok.", "SRK.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace("EventFeature.", "SBH.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".CrimePunishments.", ".NKZPNE.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".CrimeSubjectStatisticData.", ".SBC.", StringComparison.InvariantCulture);
fieldPrefix = fieldPrefix.Replace(".CiminalProceedingCrime.", ".NPRPNESTA.", StringComparison.InvariantCulture);
if (fieldPrefix.Contains("NPR.DLO.PNE.NPRFZLPNE.SCQ.", StringComparison.InvariantCulture) ||
fieldPrefix.Contains("NPR.DLO.PNE.NPRFZLPNE.SBC.", StringComparison.InvariantCulture))
{
fieldPrefix = fieldPrefix.Replace(".PNE.", ".", StringComparison.InvariantCulture);
}
return(fieldPrefix);
}
catch (Exception ex)
{
}
return("");
}
public static IHtmlContent EnumDropDownListForStringValue <TModel, TEnum>(this IHtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TEnum> > expression, object htmlAttributes = null)
{
var modelExplorer = ExpressionMetadataProvider.FromLambdaExpression(expression, htmlHelper.ViewData, htmlHelper.MetadataProvider);
Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata metadata = modelExplorer.Metadata;
Type enumType = GetNonNullableModelType(metadata);
Type baseEnumType = Enum.GetUnderlyingType(enumType);
var items = ToSelectList(enumType).ToList();
if (metadata.IsNullableValueType)
{
items.Insert(0, new SelectListItem {
Text = "", Value = ""
});
}
return(htmlHelper.DropDownListFor(expression, items, htmlAttributes));
}
public static string GetEisppRuleFullName(this Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata model, string fieldPrefix, bool isVM)
{
try
{
if (model.ContainerType != null)
{
if (!fieldPrefix.StartsWith("Data.Events[0]."))
{
fieldPrefix = "Data.Events[0]." + fieldPrefix.Replace("NewEventObj.", "");
}
fieldPrefix = model.GetEisppRulePath(fieldPrefix);
string propertyName = model.PropertyName;
if (isVM && propertyName.EndsWith("VM"))
{
propertyName = propertyName.Substring(0, propertyName.Length - 2);
}
var Member = model.ContainerType.GetMember(propertyName);
object[] attribs = Member[0].GetCustomAttributes(typeof(System.Xml.Serialization.XmlAttributeAttribute), false);
bool doesPropertyHaveAttrib = attribs.Length > 0;
if (doesPropertyHaveAttrib)
{
string name = ((System.Xml.Serialization.XmlAttributeAttribute)attribs[0]).AttributeName;
if (fieldPrefix.Contains("."))
{
fieldPrefix = fieldPrefix.Replace("." + model.PropertyName, "." + name, StringComparison.InvariantCulture);
}
else
{
fieldPrefix = fieldPrefix.Replace(model.PropertyName, name, StringComparison.InvariantCulture);
}
return(fieldPrefix);
}
}
}
catch (Exception ex)
{
}
return("");
}
public static string GetIOReqClass(this Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata model)
{
string result = "";
try
{
if (model.ContainerType != null)
{
var Member = model.ContainerType.GetMember(model.PropertyName);
var reqTypes = new[] { typeof(Attributes.IORequiredAttribute), typeof(RequiredAttribute), typeof(RangeAttribute) };
var hasIOreq = Member[0].CustomAttributes.Any(a => reqTypes.Contains(a.AttributeType));
if (hasIOreq)
{
result = "io-req";
}
}
}
catch { }
return(result);
}
public static IHtmlContent EnumDropDownListForStringValue <TModel, TEnum>(this IHtmlHelper <TModel> htmlHelper, Expression <Func <TModel, TEnum> > expression, object htmlAttributes = null)
{
var modelExplorer = ExpressionMetadataProvider.FromLambdaExpression(expression, htmlHelper.ViewData, htmlHelper.MetadataProvider);
Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata metadata = modelExplorer.Metadata;
Type enumType = GetNonNullableModelType(metadata);
Type baseEnumType = Enum.GetUnderlyingType(enumType);
List <SelectListItem> items = new List <SelectListItem>();
foreach (FieldInfo field in enumType.GetFields(BindingFlags.Static | BindingFlags.GetField | BindingFlags.Public))
{
string text = field.Name;
string value = field.Name;
bool selected = field.GetValue(null).Equals(modelExplorer.Model);
foreach (DisplayAttribute displayAttribute in field.GetCustomAttributes(true).OfType <DisplayAttribute>())
{
text = displayAttribute.GetName();
}
items.Add(new SelectListItem()
{
Text = text,
Value = value,
Selected = selected
});
}
if (metadata.IsNullableValueType)
{
items.Insert(0, new SelectListItem {
Text = "", Value = ""
});
}
return(htmlHelper.DropDownListFor(expression, items, htmlAttributes));
}
public static bool IsValidForEnumHelper(Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata metadata)
{
return(metadata != null && IsValidForEnumHelper(metadata.ModelType));
}
public FluentValidationModelValidator(Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata metadata, IValidator validator)
{
this.validator = validator;
//customizations = null;// CustomizeValidatorAttribute.GetFromControllerContext(actionContext) ?? new CustomizeValidatorAttribute();
}
public static IList <SelectListItem> GetSelectListFromDatabase <TDbContext>(this IHtmlHelper <dynamic> htmlHelper, string propertyName, bool selectedOnly = false) where TDbContext : DbContext
{
var modelExplorer = ExpressionMetadataProvider.FromStringExpression(propertyName, htmlHelper.ViewData, htmlHelper.MetadataProvider);
Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata metadata = modelExplorer.Metadata;
var dropdownModelType = ((Type)metadata.AdditionalValues["DropdownModelType"]);
var keyProperty = ((string)metadata.AdditionalValues["KeyProperty"]);
var valueProperty = ((string)metadata.AdditionalValues["DisplayExpression"]);
var bindingProperty = ((string)metadata.AdditionalValues["BindingProperty"]);
var orderByProperty = ((string)metadata.AdditionalValues["OrderByProperty"]);
var orderByType = ((string)metadata.AdditionalValues["OrderByType"]);
var physicalFilePath = ((string)metadata.AdditionalValues["PhysicalFilePath"]);
var fileFolderId = ((string)metadata.AdditionalValues["FileFolderId"]);
if (!string.IsNullOrEmpty(fileFolderId))
{
physicalFilePath = Server.GetWwwFolderPhysicalPathById(fileFolderId);
}
var physicalFolderPath = ((string)metadata.AdditionalValues["PhysicalFolderPath"]);
var folderFolderId = ((string)metadata.AdditionalValues["FolderFolderId"]);
if (!string.IsNullOrEmpty(folderFolderId))
{
physicalFolderPath = Server.GetWwwFolderPhysicalPathById(folderFolderId);
}
var nullable = ((bool)metadata.AdditionalValues["Nullable"]);
var options = ((IEnumerable <string>)metadata.AdditionalValues["Options"]);
Type propertyType = GetNonNullableModelType(metadata);
List <SelectListItem> items = new List <SelectListItem>();
List <string> ids = new List <string>();
if (propertyType != typeof(string) && (propertyType.GetInterfaces().Contains(typeof(IEnumerable))))
{
if (modelExplorer.Model != null)
{
foreach (var val in (IEnumerable)modelExplorer.Model)
{
if (val != null)
{
if (!string.IsNullOrWhiteSpace(bindingProperty))
{
ids.Add(val.GetPropValue(bindingProperty).ToString());
}
else
{
ids.Add(val.ToString());
}
}
}
}
}
else
{
if (modelExplorer.Model != null)
{
if (!string.IsNullOrWhiteSpace(bindingProperty))
{
ids.Add(modelExplorer.Model.GetPropValue(bindingProperty).ToString());
}
else
{
ids.Add(modelExplorer.Model.ToString());
}
}
}
if (!string.IsNullOrEmpty(physicalFolderPath))
{
var repository = htmlHelper.FileSystemGenericRepositoryFactory().CreateFolderRepositoryReadOnly(default(CancellationToken), physicalFolderPath, true);
var data = repository.GetAll(LamdaHelper.GetOrderByFunc <DirectoryInfo>(orderByProperty, orderByType), null, null);
keyProperty = nameof(DirectoryInfo.FullName);
data.ToList().ForEach(item =>
items.Add(new SelectListItem()
{
Text = GetDisplayString(htmlHelper, item, valueProperty).Replace(physicalFolderPath, ""),
Value = item.GetPropValue(nameof(DirectoryInfo.FullName)) != null ? item.GetPropValue(nameof(DirectoryInfo.FullName)).ToString().Replace(physicalFolderPath, "") : "",
Selected = item.GetPropValue(keyProperty) != null && ids.Contains(item.GetPropValue(keyProperty).ToString().Replace(physicalFolderPath, ""))
}));
}
else if (!string.IsNullOrEmpty(physicalFilePath))
{
var repository = htmlHelper.FileSystemGenericRepositoryFactory().CreateFileRepositoryReadOnly(default(CancellationToken), physicalFilePath, true);
var data = repository.GetAll(LamdaHelper.GetOrderByFunc <FileInfo>(orderByProperty, orderByType), null, null);
keyProperty = nameof(FileInfo.FullName);
data.ToList().ForEach(item =>
items.Add(new SelectListItem()
{
Text = GetDisplayString(htmlHelper, item, valueProperty),
Value = item.GetPropValue(keyProperty) != null ? item.GetPropValue(keyProperty).ToString().Replace(physicalFilePath, "") : "",
Selected = item.GetPropValue(keyProperty) != null && ids.Contains(item.GetPropValue(keyProperty).ToString().Replace(physicalFilePath, ""))
}));
}
else if (metadata.DataTypeName == "ModelRepeater")
{
foreach (var item in htmlHelper.ViewData.Model)
{
var itemObject = (Object)item;
items.Add(new SelectListItem()
{
Text = GetDisplayString(htmlHelper, item, valueProperty),
Value = itemObject.GetPropValue(keyProperty) != null ? itemObject.GetPropValue(keyProperty).ToString() : "",
Selected = itemObject.GetPropValue(keyProperty) != null && ids.Contains(itemObject.GetPropValue(keyProperty).ToString())
});
}
}
else
{
//db
if (options == null)
{
using (var db = htmlHelper.DatabaseByEntityType(dropdownModelType))
{
var pi = dropdownModelType.GetProperty(orderByProperty);
Type iQueryableType = typeof(IQueryable <>).MakeGenericType(new[] { dropdownModelType });
IQueryable query = db.Queryable(dropdownModelType);
if (selectedOnly)
{
var whereClause = LamdaHelper.SearchForEntityByIds(dropdownModelType, ids.Cast <Object>());
query = (IQueryable)typeof(LamdaHelper).GetMethod(nameof(LamdaHelper.Where)).MakeGenericMethod(dropdownModelType).Invoke(null, new object[] { query, whereClause });
}
else
{
if (metadata.AdditionalValues.ContainsKey("WhereClauseEqualsDictionary"))
{
var whereClauseEqualsDictionary = (Dictionary <string, List <object> >)metadata.AdditionalValues["WhereClauseEqualsDictionary"];
foreach (var where in whereClauseEqualsDictionary)
{
var whereClause = LamdaHelper.SearchForEntityByProperty(dropdownModelType, where.Key, where.Value);
query = (IQueryable)typeof(LamdaHelper).GetMethod(nameof(LamdaHelper.Where)).MakeGenericMethod(dropdownModelType).Invoke(null, new object[] { query, whereClause });
}
}
if (!string.IsNullOrWhiteSpace(orderByProperty))
{
if (orderByType == "asc")
{
query = (IQueryable)typeof(Utilities).GetMethod(nameof(Utilities.QueryableOrderBy)).MakeGenericMethod(dropdownModelType).Invoke(null, new object[] { query, orderByProperty, true });
}
else
{
query = (IQueryable)typeof(Utilities).GetMethod(nameof(Utilities.QueryableOrderBy)).MakeGenericMethod(dropdownModelType).Invoke(null, new object[] { query, orderByProperty, false });
}
}
}
IEnumerable results = query.ToList(dropdownModelType);
foreach (var item in results)
{
items.Add(new SelectListItem()
{
Text = GetDisplayString(htmlHelper, item, valueProperty),
//Value = item.GetPropValue(keyProperty) != null ? item.GetPropValue(keyProperty).ToString() : "",
//Selected = item.GetPropValue(keyProperty) != null && ids.Contains(item.GetPropValue(keyProperty).ToString())
Value = GetDisplayString(htmlHelper, item, keyProperty),
Selected = ids.Contains(GetDisplayString(htmlHelper, item, keyProperty))
});
}
}
}
else
{
options.ToList().ForEach(item =>
items.Add(new SelectListItem()
{
Text = item,
Value = item,
Selected = ids.Contains(item)
}));
}
}
if (metadata.IsNullableValueType || nullable)
{
items.Insert(0, new SelectListItem {
Text = "", Value = ""
});
}
return(items);
}
protected virtual string GetErrorMessage(Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata modelMetadata, params object[] arguments)
{
throw null;
}
public static IList <SelectListItem> GetSelectList(this IHtmlHelper <dynamic> htmlHelper, string propertyName, bool selectedOnly = false)
{
var modelExplorer = ExpressionMetadataProvider.FromStringExpression(propertyName, htmlHelper.ViewData, htmlHelper.MetadataProvider);
Microsoft.AspNetCore.Mvc.ModelBinding.ModelMetadata metadata = modelExplorer.Metadata;
var dropdownModelType = ((Type)metadata.AdditionalValues["DropdownModelType"]);
var keyProperty = ((string)metadata.AdditionalValues["KeyProperty"]);
var valueProperty = ((string)metadata.AdditionalValues["DisplayExpression"]);
var bindingProperty = ((string)metadata.AdditionalValues["BindingProperty"]);
var orderByProperty = ((string)metadata.AdditionalValues["OrderByProperty"]);
var orderByType = ((string)metadata.AdditionalValues["OrderByType"]);
var physicalFilePath = ((string)metadata.AdditionalValues["PhysicalFilePath"]);
var physicalFolderPath = ((string)metadata.AdditionalValues["PhysicalFolderPath"]);
var nullable = ((bool)metadata.AdditionalValues["Nullable"]);
var options = ((IEnumerable <string>)metadata.AdditionalValues["Options"]);
Type propertyType = GetNonNullableModelType(metadata);
List <SelectListItem> items = new List <SelectListItem>();
List <string> ids = new List <string>();
if (propertyType != typeof(string) && (propertyType.GetInterfaces().Contains(typeof(IEnumerable))))
{
if (modelExplorer.Model != null)
{
foreach (var val in (IEnumerable)modelExplorer.Model)
{
if (val != null)
{
if (!string.IsNullOrWhiteSpace(bindingProperty))
{
ids.Add(val.GetPropValue(bindingProperty).ToString());
}
else
{
ids.Add(val.ToString());
}
}
}
}
}
else
{
if (modelExplorer.Model != null)
{
if (!string.IsNullOrWhiteSpace(bindingProperty))
{
ids.Add(modelExplorer.Model.GetPropValue(bindingProperty).ToString());
}
else
{
ids.Add(modelExplorer.Model.ToString());
}
}
}
if (metadata.DataTypeName == "ModelRepeater")
{
foreach (var item in htmlHelper.ViewData.Model)
{
var itemObject = (Object)item;
items.Add(new SelectListItem()
{
Text = GetDisplayString(htmlHelper, item, valueProperty),
Value = itemObject.GetPropValue(keyProperty) != null ? itemObject.GetPropValue(keyProperty).ToString() : "",
Selected = itemObject.GetPropValue(keyProperty) != null && ids.Contains(itemObject.GetPropValue(keyProperty).ToString())
});
}
}
else
{
//db
if (options == null)
{
}
else
{
options.ToList().ForEach(item =>
items.Add(new SelectListItem()
{
Text = item,
Value = item,
Selected = ids.Contains(item)
}));
}
}
if (metadata.IsNullableValueType || nullable)
{
items.Insert(0, new SelectListItem {
Text = "", Value = ""
});
}
return(items);
}
