public async Task <AdminSearchResult> GetModelListHasPerAsync(string isAdmin, string mobile, DateTime?startTime, DateTime?endTime, int pageIndex, int pageSize)
{
using (MyDbContext dbc = new MyDbContext())
{
AdminSearchResult result = new AdminSearchResult();
var admins = dbc.GetAll <AdminEntity>();
if (isAdmin != "admin")
{
admins = admins.Where(a => a.Mobile != "admin");
}
if (!string.IsNullOrEmpty(mobile))
{
admins = admins.Where(a => a.Mobile.Contains(mobile));
}
if (startTime != null)
{
admins = admins.Where(a => a.CreateTime.Year >= startTime.Value.Year && a.CreateTime.Month >= startTime.Value.Month && a.CreateTime.Day >= startTime.Value.Day);
}
if (endTime != null)
{
admins = admins.Where(a => a.CreateTime.Year <= endTime.Value.Year && a.CreateTime.Month <= endTime.Value.Month && a.CreateTime.Day <= endTime.Value.Day);
}
result.TotalCount = await admins.LongCountAsync();
var adminsResult = await admins.OrderByDescending(a => a.CreateTime).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToListAsync();
result.Admins = adminsResult.Select(a => ToDTO(a)).ToArray();
return(result);
}
}
public async Task <AdminSearchResult> GetModelListAsync(string isAdmin, string keyword, DateTime?startTime, DateTime?endTime, int pageIndex, int pageSize)
{
using (MyDbContext dbc = new MyDbContext())
{
AdminSearchResult result = new AdminSearchResult();
var admins = dbc.GetAll <AdminEntity>().AsNoTracking();
if (isAdmin != "admin")
{
admins = admins.Where(a => a.Mobile == isAdmin);
}
else
{
if (!string.IsNullOrEmpty(keyword))
{
admins = admins.Where(a => a.Mobile.Contains(keyword));
}
if (startTime != null)
{
admins = admins.Where(a => a.CreateTime >= startTime);
}
if (endTime != null)
{
admins = admins.Where(a => SqlFunctions.DateDiff("day", endTime, a.CreateTime) <= 0);
}
}
result.PageCount = (int)Math.Ceiling((await admins.LongCountAsync()) * 1.0f / pageSize);
var adminsResult = await admins.OrderByDescending(a => a.CreateTime).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToListAsync();
result.Admins = adminsResult.Select(a => ToDTO(a)).ToArray();
return(result);
}
}
public async Task <ActionResult> List(string keyword, DateTime?startTime, DateTime?endTime, int pageIndex = 1)
{
AdminSearchResult result = await adminService.GetModelListAsync("admin", keyword, startTime, endTime, pageIndex, pageSize);
ListViewModel model = new ListViewModel();
model.Admins = result.Admins;
PermissionTypeDTO[] types = await permissionTypeService.GetModelList();
List <PermissionType> permissionTypes = new List <PermissionType>();
foreach (var type in types)
{
PermissionType permissionType = new PermissionType();
permissionType.Name = type.Name;
PermissionDTO[] permissions = await permissionService.GetByTypeIdAsync(type.Id);
permissionType.Permissions = permissions.ToList();
permissionTypes.Add(permissionType);
}
model.PermissionTypes = permissionTypes;
model.PageCount = result.PageCount;
return(Json(new AjaxResult {
Status = 1, Data = model
}));
}
public PartialViewResult AdminManagerGetPage(int pageIndex = 1)
{
int pageSize = 3;
AdminListViewModel model = new AdminListViewModel();
AdminSearchResult result = adminService.GetPageList(pageIndex, pageSize);
model.AdminList = result.AdminList;
//分页
Pagination pager = new Pagination();
pager.PageIndex = pageIndex;
pager.PageSize = pageSize;
pager.TotalCount = result.TotalCount;
if (result.TotalCount <= pageSize)
{
model.Page = "";
}
else
{
model.Page = pager.GetPagerHtml();
}
return(PartialView("AdminManagerPaging", model));
}
public async Task <AdminSearchResult> GetModelListAsync(string keyword, DateTime?startTime, DateTime?endTime, int pageIndex, int pageSize)
{
using (MyDbContext dbc = new MyDbContext())
{
AdminSearchResult result = new AdminSearchResult();
var entities = dbc.GetAll <AdminEntity>().AsNoTracking();
if (!string.IsNullOrEmpty(keyword))
{
entities = entities.Where(a => a.Name.Contains(keyword));
}
if (startTime != null)
{
entities = entities.Where(a => a.CreateTime >= startTime);
}
if (endTime != null)
{
entities = entities.Where(a => a.CreateTime.Year <= endTime.Value.Year && a.CreateTime.Month <= endTime.Value.Month && a.CreateTime.Day <= endTime.Value.Day);
}
result.PageCount = (int)Math.Ceiling((await entities.LongCountAsync()) * 1.0f / pageSize);
var res = await entities.OrderByDescending(a => a.CreateTime).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToListAsync();
result.List = res.Select(a => ToDTO(a, dbc.GetAll <AdminPermissionEntity>().Where(ap => ap.AdminId == a.Id).Select(ap => ap.PermissionId).ToArray())).ToArray();
return(result);
}
}
public AdminSearchResult GetPageList(int pageIndex, int pageSize)
{
using (MyDbContext dbc = new MyDbContext())
{
AdminSearchResult result = new AdminSearchResult();
CommonService <AdminEntity> cs = new CommonService <AdminEntity>(dbc);
var admins = cs.GetAll();
//admins = admins.Where(a => a.Name != "admin");
result.TotalCount = admins.LongCount();
result.AdminList = admins.OrderByDescending(a => a.CreateTime).Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList().Select(a => ToDTO(a)).ToArray();
return(result);
}
}
public async Task <IActionResult> Search(PagerParameters pagerParameters, IList <KeyValuePair <string, string[]> > filters, string searchTerm)
{
var siteSettings = await _siteService.GetSiteSettingsAsync();
var searchContext = new AdminSearchContext
{
Index = _adminSearchSettings.AdminSearchIndex,
ContentTypes = _contentDefinitionManager.ListTypeDefinitions().Select(c => c.Name).ToArray(), // TODO: Once content types have a setting for which indexes they use, this should be updated to obey that
IndexFieldsToSearch = _adminSearchSettings.AdminSearchFields,
PageSize = pagerParameters.PageSize ?? siteSettings.PageSize,
PageNumber = pagerParameters.Page ?? 1,
Filters = filters,
SearchTerm = searchTerm
};
var searchResults = new AdminSearchResult();
if (filters.Any() || !string.IsNullOrWhiteSpace(searchTerm))
{
searchResults = await _searchService.SearchContent(searchContext);
}
var model = new AdminSearchViewModel
{
SearchFilters = await _adminSearchFilters.InvokeAsync(x => x.GetFilter(searchContext.ContentTypes), null),
SearchTerm = searchContext.SearchTerm,
ContentItems = searchResults.ContentItems,
TotalRecordCount = searchResults.TotalRecordCount,
PageSize = searchContext.PageSize,
PageNumber = searchContext.PageNumber,
Filters = searchContext.Filters
};
var pager = new Pager(pagerParameters, siteSettings.PageSize);
var pagerShape = (await New.Pager(pager))
.TotalItemCount(searchResults.TotalRecordCount)
.ShowNext(searchResults.TotalRecordCount > searchContext.PageSize * (searchContext.PageNumber + 1));
model.Pager = pagerShape;
return(View(model));
}
public async Task <IActionResult> List(string keyword, DateTime?startTime, DateTime?endTime, int pageIndex = 1)
{
AdminSearchResult res = await adminService.GetModelListAsync(keyword, startTime, endTime, pageIndex, pageSize);
string[] types = await permissionService.GetModelTypeListIsEnableAsync();
List <PermTypeModel> permTypes = new List <PermTypeModel>();
ListViewModel model = new ListViewModel();
model.List = res.List;
foreach (var item in types)
{
PermTypeModel typeModel = new PermTypeModel();
typeModel.TypeName = item;
typeModel.Permissions = await permissionService.GetModelListIsEnableByTypeNameAsync(item);
permTypes.Add(typeModel);
}
model.PermTypes = permTypes;
model.PageCount = res.PageCount;
return(Json(new AjaxResult {
Status = 1, Data = model
}));
}
public ActionResult ExportExcel()
{
AdminSearchResult result = adminService.GetPageList(1, 10);
return(File(ExcelHelper.ExportExcel <AdminListDTO>(result.AdminList, "管理员"), "application/vnd.ms-excel", "测试.xls"));
}
public async Task <AdminSearchResult> SearchContent(AdminSearchContext searchContext)
{
var searchResult = new AdminSearchResult();
await _luceneIndexProvider.SearchAsync(searchContext.Index, async searcher =>
{
Query query;
if (string.IsNullOrWhiteSpace(searchContext.SearchTerm))
{
query = new MatchAllDocsQuery();
}
else
{
var luceneVersion = LuceneSettings.DefaultVersion;
var analyzer = new StandardAnalyzer(luceneVersion);
var multiFieldQuery = new MultiFieldQueryParser(luceneVersion, searchContext.IndexFieldsToSearch, analyzer);
query = multiFieldQuery.Parse(QueryParserBase.Escape(searchContext.SearchTerm));
}
searchContext.PageNumber -= 1;
var start = searchContext.PageNumber * searchContext.PageSize;
var end = searchContext.PageNumber * searchContext.PageSize + searchContext.PageSize;
var collector = TopScoreDocCollector.Create(end, true);
var filter = new BooleanFilter();
if (searchContext.ContentTypes.Any())
{
filter.Add(new FieldCacheTermsFilter("Content.ContentItem.ContentType", searchContext.ContentTypes), Occur.MUST);
}
if (searchContext.Filters != null && searchContext.Filters.Any())
{
await _searchFilters.InvokeAsync(x => x.Filter(searchContext, filter), null);
}
if (filter.Any())
{
searcher.Search(query, filter, collector);
}
else
{
searcher.Search(query, collector);
}
var docs = collector.GetTopDocs(start, end);
searchResult.TotalRecordCount = docs.TotalHits;
var contentItemIds = docs.ScoreDocs.Select(hit =>
{
var doc = searcher.Doc(hit.Doc);
return(doc.GetField("ContentItemId").GetStringValue());
});
searchResult.ContentItems = await _contentManager.GetAsync(contentItemIds);
});
return(searchResult);
}
