public async Task <IEnumerable <SelectListItem> > GetSelectListAsync(SelectListContext context)
{
var items = await GetSelectListItemsAsync(context);
if (items == null)
{
return(null);
}
var itemList = items.ToList();
if (SetSelectedAutomatically)
{
if (context.CurrentValues != null)
{
foreach (var item in itemList)
{
var value = item.Value ?? item.Text;
item.Selected = context.CurrentValues.Contains(value);
}
}
}
if (context.SelectedOnly)
{
itemList.RemoveAll(item => !item.Selected);
}
if ((context.ModelExplorer.Metadata.IsNullableValueType && Nullable) || Nullable)
{
if (!context.SelectedOnly)
{
itemList.Insert(0, new SelectListItem {
Text = "", Value = "", Selected = SetSelectedAutomatically ? (context.CurrentValues == null || context.CurrentValues.Count == 0) : false
});
}
else if (itemList.Count == 0)
{
itemList.Insert(0, new SelectListItem {
Text = "", Value = "", Selected = true
});
}
}
return(itemList);
}
protected override Task <IEnumerable <SelectListItem> > GetSelectListItemsAsync(SelectListContext context)
{
return(Task.FromResult(context.Html.GetEnumSelectList(EnumType ?? context.Metadata.ElementType ?? context.ModelType)));
}
protected abstract Task <IEnumerable <SelectListItem> > GetSelectListItemsAsync(SelectListContext context);
protected override async Task <IEnumerable <SelectListItem> > GetSelectListItemsAsync(SelectListContext context)
{
//Get DbContext from DI container
DbContext db = (DbContext)context.HttpContext.RequestServices.GetService(DbContextType);
if (db == null)
{
throw new Exception("Database not found");
}
//Get DbSet as IQueryable
IQueryable query = (IQueryable)_dbContextSetMethod.MakeGenericMethod(ModelType).Invoke(db, null);
if (!string.IsNullOrEmpty(RawSql))
{
query = (IQueryable)RelationalQueryableExtensions.FromSql((dynamic)query, RawSql, RawSqlParameters);
}
if (!EnableChangeTracking)
{
query = (IQueryable)EntityFrameworkQueryableExtensions.AsNoTracking((dynamic)query);
}
if (context.SelectedOnly)
{
//Select by Id
var whereClause = DbContextHelper.SearchForEntityByValues(ModelType, DataValueField, context.CurrentValues);
query = (IQueryable)_dbContextWhereClauseMethod.MakeGenericMethod(ModelType).Invoke(null, new object[] { query, whereClause });
}
else
{
if (context.ModelExplorer.Metadata is DefaultModelMetadata defaultModelMetadata)
{
//Loop over where clauses
IEnumerable <SelectListDbWhereEqualsAttribute> whereClauseAttributes = null;
if (defaultModelMetadata.MetadataKind == ModelMetadataKind.Property)
{
whereClauseAttributes = defaultModelMetadata.Attributes.PropertyAttributes.OfType <SelectListDbWhereEqualsAttribute>().Where(a => a.SelectListId == this.SelectListId);
}
else if (defaultModelMetadata.MetadataKind == ModelMetadataKind.Type)
{
whereClauseAttributes = defaultModelMetadata.Attributes.TypeAttributes.OfType <SelectListDbWhereEqualsAttribute>().Where(a => a.SelectListId == this.SelectListId);
}
if (whereClauseAttributes != null)
{
foreach (var where in whereClauseAttributes)
{
var whereClause = LamdaHelper.SearchForEntityByProperty(ModelType, where.PropertyName, where.Values);
query = (IQueryable)_dbContextWhereClauseMethod.MakeGenericMethod(ModelType).Invoke(null, new object[] { query, whereClause });
}
}
}
}
//Order By
if (!string.IsNullOrWhiteSpace(OrderByProperty))
{
if (OrderByType == "asc")
{
query = (IQueryable)_dbContextOrderByMethod.MakeGenericMethod(ModelType).Invoke(null, new object[] { query, OrderByProperty, true });
}
else
{
query = (IQueryable)_dbContextOrderByMethod.MakeGenericMethod(ModelType).Invoke(null, new object[] { query, OrderByProperty, false });
}
}
//Skip
query = (IQueryable)Queryable.Skip((dynamic)query, Skip);
//Take
query = (IQueryable)Queryable.Take((dynamic)query, Take);
//Get Results
IEnumerable results = (IEnumerable)(await EntityFrameworkQueryableExtensions.ToListAsync((dynamic)query, CancellationToken.None));
return(new ModelMultiSelectList(context.Html, results, DataValueField, DataTextFieldExpression));
}
protected async override Task <IEnumerable <SelectListItem> > GetSelectListItemsAsync(SelectListContext context)
{
var dataValueField = nameof(FileInfo.FullName);
if (!Path.EndsWith(@"\"))
{
Path = Path + @"\";
}
var hostingEnvironment = context.HttpContext.RequestServices.GetRequiredService <IHostingEnvironment>();
var mappedWwwPath = hostingEnvironment.MapWwwPath(Path);
var mappedContentPath = hostingEnvironment.MapContentPath(Path);
var searchPath = Path;
var root = "";
var webFolder = false;
if (mappedWwwPath != mappedContentPath)
{
searchPath = mappedContentPath;
root = hostingEnvironment.ContentRootPath + @"\";
if (Directory.Exists(mappedWwwPath))
{
webFolder = true;
searchPath = mappedWwwPath;
root = hostingEnvironment.WebRootPath + @"\";
}
}
var repository = _fileSystemGenericRepositoryFactory.CreateFileRepositoryReadOnly(default(CancellationToken), searchPath, IncludeSubDirectories, SearchPattern);
var data = await repository.GetAllAsync(LamdaHelper.GetOrderByFunc <FileInfo>(OrderByProperty, OrderByType), null, null);
var results = new List <SelectListItem>();
foreach (var item in data)
{
IHtmlHelper html = context.CreateHtmlHelper((dynamic)item);
results.Add(new ModelSelectListItem()
{
Model = item,
Html = html,
Text = RemoveSearchPathFromText ? context.Eval(html, item, DataTextFieldExpression).Replace(searchPath, "") : context.Eval(html, item, DataTextFieldExpression),
Value = RootRelativeValue ? webFolder ? context.Eval(html, item, dataValueField).Replace(root, "").Replace(@"\", @"/") : context.Eval(html, item, dataValueField).Replace(root, "") : context.Eval(html, item, dataValueField),
});
}
return(results);
}
protected override Task <IEnumerable <SelectListItem> > GetSelectListItemsAsync(SelectListContext context)
{
var results = new List <SelectListItem>();
for (int i = 0; i < _text.Length; i++)
{
IHtmlHelper html = context.CreateHtmlHelper((dynamic)_values[i]);
results.Add(new ModelSelectListItem()
{
Model = _values[i],
Html = html,
Text = _text[i].ToString(),
Value = _values[i].ToString()
});
}
return(Task.FromResult(results.AsEnumerable()));
}
protected override Task <IEnumerable <SelectListItem> > GetSelectListItemsAsync(SelectListContext context)
{
if (context.Model != null)
{
return(Task.FromResult(new ModelMultiSelectList(context.Html, (IEnumerable)context.Model, DataValueField, DataTextFieldExpression, (IEnumerable)context.Model).AsEnumerable <SelectListItem>()));
}
else
{
return(Task.FromResult(Enumerable.Empty <SelectListItem>()));
}
}
protected override Task <IEnumerable <SelectListItem> > GetSelectListItemsAsync(SelectListContext context)
{
Dictionary <string, RegionInfo> countryList = new Dictionary <string, RegionInfo>();
CultureInfo[] cInfoList = CultureInfo.GetCultures(CultureTypes.SpecificCultures);
foreach (CultureInfo CInfo in cInfoList)
{
RegionInfo R = new RegionInfo(CInfo.LCID);
if (!(countryList.ContainsKey(R.EnglishName)))
{
countryList.Add(R.EnglishName, R);
}
}
return(Task.FromResult(new ModelSelectList(context.Html, countryList.Keys.OrderBy(k => k).Select(k => countryList[k]), DataValueFieldExpression, DataTextFieldExpression).AsEnumerable <SelectListItem>()));
}