/// <summary>
/// 过滤数据
/// </summary>
public void OnQuery(
StaticTableSearchRequest request, IDatabaseContext context, ref IQueryable <Database.Article> query)
{
// 按分类
var classId = request.Conditions.GetOrDefault <long?>("class");
if (classId != null)
{
query = query.Where(q => q.Classes.Any(c => c.Id == classId));
}
// 按标签
var tagId = request.Conditions.GetOrDefault <long?>("tag");
if (tagId != null)
{
query = query.Where(q => q.Tags.Any(t => t.Id == tagId));
}
// 按关键词
if (!string.IsNullOrEmpty(request.Keyword))
{
query = query.Where(q =>
q.Title.Contains(request.Keyword) ||
q.Summary.Contains(request.Keyword) ||
q.Author.Username == request.Keyword);
}
// 只显示未删除的文章
query = query.Where(q => !q.Deleted);
}
/// <summary>
/// 从数据库中的数据构建搜索回应
/// 支持自动分页和配合表格回调设置结果
/// </summary>
/// <typeparam name="TData">数据类型</typeparam>
/// <param name="request">搜索请求</param>
/// <param name="callbacks">表格回调</param>
/// <returns></returns>
public static StaticTableSearchResponse BuildResponseFromDatabase<TData>(
this StaticTableSearchRequest request, IEnumerable<IStaticTableCallback<TData>> callbacks)
where TData : class, IEntity {
var response = new StaticTableSearchResponse();
UnitOfWork.Read(context => {
// 从数据库获取数据，过滤并排序
var query = context.Query<TData>();
foreach (var callback in callbacks) {
callback.OnQuery(request, context, ref query);
}
foreach (var callback in callbacks) {
callback.OnSort(request, context, ref query);
}
// 分页并设置分页信息
// 当前页没有任何内容时返回最后一页的数据
var queryResult = response.Pagination.Paging(request, query);
response.PageNo = request.PageNo;
response.PageSize = request.PageSize;
// 选择数据
// 默认把对象转换到的字符串保存到ToString中
var pairs = queryResult
.Select(r => new EntityToTableRow<TData>(r))
.ToList();
foreach (var pair in pairs) {
pair.Row["ToString"] = pair.Entity.ToString();
}
foreach (var callback in callbacks) {
callback.OnSelect(request, pairs);
}
response.Rows = pairs.Select(p => p.Row).ToList();
});
return response;
}
public IActionResult StaticTable()
{
var request = StaticTableSearchRequest.FromHttpRequest();
var handlers = new ExampleStaticTableHandler().WithExtraHandlers();
var response = request.BuildResponse(handlers);
return(new TemplateResult("zkweb.examples/static_table.html", new { response }));
}
public override void OnQuery(
StaticTableSearchRequest request, ref IQueryable <ExampleTable> query)
{
if (!string.IsNullOrEmpty(request.Keyword))
{
query = query.Where(q => q.Name.Contains(request.Keyword));
}
}
/// <summary>
/// 过滤数据
/// </summary>
public override void OnQuery(
StaticTableSearchRequest request, ref IQueryable <Product> query)
{
// 按分类
var classId = request.Conditions.GetOrDefault <Guid?>("class");
if (classId != null)
{
query = query.Where(q => q.Classes.Any(c => c.Id == classId));
}
// 按分类列表
var classIds = request.Conditions.GetOrDefault <IList <Guid> >("classes");
if (classIds != null && classIds.Count > 0)
{
query = query.Where(q => q.Classes.Any(c => classIds.Contains(c.Id)));
}
// 按标签
var tagId = request.Conditions.GetOrDefault <Guid?>("tag");
if (tagId != null)
{
query = query.Where(q => q.Tags.Any(t => t.Id == tagId));
}
// 按标签列表
var tagIds = request.Conditions.GetOrDefault <IList <Guid> >("tags");
if (tagIds != null && tagIds.Count > 0)
{
query = query.Where(q => q.Tags.Any(t => tagIds.Contains(t.Id)));
}
// 按价格范围（这里不考虑货币）
var priceRange = request.Conditions.GetOrDefault <string>("price_range");
if (!string.IsNullOrEmpty(priceRange) && priceRange.Contains('~'))
{
var priceBounds = priceRange.Split('~');;
var lowerBound = priceBounds[0].ConvertOrDefault <decimal>();
var upperBound = priceBounds[1].ConvertOrDefault <decimal>();
query = query.Where(q => q.MatchedDatas.Any(d => d.Price != null && d.Price >= lowerBound));
if (upperBound > 0)
{
query = query.Where(q => q.MatchedDatas.Any(d => d.Price != null && d.Price <= upperBound));
}
}
// 按关键词
if (!string.IsNullOrEmpty(request.Keyword))
{
query = query.Where(q => q.Name.Contains(request.Keyword));
}
// 只显示未删除且允许显示的商品
var visibleStates = Application.Ioc.ResolveMany <IProductState>()
.Where(s => s is IAmVisibleToThePublic)
.Select(s => s.State).ToList();
query = query.Where(q => !q.Deleted && visibleStates.Contains(q.State));
}
public override void OnSelect(
StaticTableSearchRequest request, IList <EntityToTableRow <ExampleTable> > pairs)
{
foreach (var pair in pairs)
{
pair.Row["Id"] = pair.Entity.Id;
pair.Row["Name"] = pair.Entity.Name;
pair.Row["CreateTime"] = pair.Entity.CreateTime.ToClientTimeString();
}
}
/// <summary>
/// 根据当前http请求获取搜索结果
/// 结果会按请求参数和当前登录用户缓存一定时间
/// </summary>
/// <returns></returns>
public virtual StaticTableSearchResponse GetArticleSearchResponseFromHttpRequest()
{
return(ArticleSearchResultCache.GetOrCreate(0, () => {
var configManager = Application.Ioc.Resolve <GenericConfigManager>();
var articleListSettings = configManager.GetData <ArticleListSettings>();
var searchRequest = StaticTableSearchRequest.FromHttpRequest(
articleListSettings.ArticlesPerPage);
var handlers = new ArticleTableHandler().WithExtraHandlers();
return searchRequest.BuildResponse(handlers);
}, ArticleSearchResultCacheTime));
}
/// <summary>
/// 根据当前http请求获取搜索结果
/// 结果会按请求参数和当前登录用户缓存一定时间
/// </summary>
/// <returns></returns>
public virtual StaticTableSearchResponse GetProductSearchResponseFromHttpRequest()
{
return(ProductSearchResultCache.GetOrCreate(0, () => {
var configManager = Application.Ioc.Resolve <GenericConfigManager>();
var productListSettings = configManager.GetData <ProductListSettings>();
var searchRequest = StaticTableSearchRequest.FromHttpRequest(
productListSettings.ProductsPerPage);
var callbacks = new ProductTableCallback().WithExtensions();
var searchResponse = searchRequest.BuildResponseFromDatabase(callbacks);
return searchResponse;
}, ProductSearchResultCacheTime));
}
/// <summary>
/// 包装查询函数
/// 默认根据搜索参数中的Deleted过滤已删除或未删除的对象
/// </summary>
public virtual Func <TResult> WrapQueryMethod <TResult>(
StaticTableSearchRequest request, Func <TResult> queryMethod)
{
var uow = Application.Ioc.Resolve <IUnitOfWork>();
var deleted = request.Conditions.GetOrDefault <bool>("Deleted");
return(() => {
using (uow.DisableQueryFilter(typeof(DeletedFilter)))
using (uow.EnableQueryFilter(new DeletedFilter(deleted))) {
return queryMethod();
}
});
}
/// <summary>
/// 从领域服务提供的数据构建搜索回应
/// 支持自动分页和配合表格处理器设置结果
/// </summary>
/// <typeparam name="TData">数据类型</typeparam>
/// <param name="request">搜索请求</param>
/// <param name="callbacks">表格处理器</param>
/// <returns></returns>
public static StaticTableSearchResponse BuildResponse <TEntity, TPrimaryKey>(
this StaticTableSearchRequest request,
IEnumerable <IStaticTableHandler <TEntity, TPrimaryKey> > handlers)
where TEntity : class, IEntity <TPrimaryKey>
{
var uow = Application.Ioc.Resolve <IUnitOfWork>();
var response = new StaticTableSearchResponse();
var service = Application.Ioc.Resolve <IDomainService <TEntity, TPrimaryKey> >();
var queryMethod = new Func <IList <TEntity> >(() => service.GetMany(query => {
// 从服务获取数据，过滤并排序
foreach (var handler in handlers)
{
handler.OnQuery(request, ref query);
}
foreach (var handler in handlers)
{
handler.OnSort(request, ref query);
}
// 分页并设置分页信息
// 当前页没有任何内容时返回最后一页的数据
return(response.Pagination.Paging(request, query));
}));
foreach (var handler in handlers)
{
// 包装查询函数
queryMethod = handler.WrapQueryMethod(request, queryMethod);
}
using (uow.Scope()) {
// 查询数据
var result = queryMethod();
// 设置当前页和每页数量
response.PageNo = request.PageNo;
response.PageSize = request.PageSize;
// 选择数据
// 默认把对象转换到的字符串保存到ToString中
var pairs = result.Select(r => new EntityToTableRow <TEntity>(r)).ToList();
foreach (var pair in pairs)
{
pair.Row["ToString"] = pair.Entity.ToString();
}
foreach (var callback in handlers)
{
callback.OnSelect(request, pairs);
}
response.Rows = pairs.Select(p => p.Row).ToList();
}
return(response);
}
/// <summary>
/// 排序数据
/// 默认更新时间或创建时间或Id倒序排列
/// </summary>
public virtual void OnSort(
StaticTableSearchRequest request, ref IQueryable <TEntity> query)
{
if (UpdateTimeTypeTrait <TEntity> .HaveUpdateTime)
{
query = query.OrderByDescending(e => ((IHaveUpdateTime)e).UpdateTime);
}
else if (CreateTimeTypeTrait <TEntity> .HaveCreateTime)
{
query = query.OrderByDescending(e => ((IHaveCreateTime)e).CreateTime);
}
else
{
query = query.OrderByDescending(e => e.Id);
}
}
/// <summary>
/// 选择数据
/// </summary>
public override void OnSelect(
StaticTableSearchRequest request, IList <EntityToTableRow <Product> > pairs)
{
var albumManager = Application.Ioc.Resolve <ProductAlbumManager>();
foreach (var pair in pairs)
{
var seller = pair.Entity.Seller;
pair.Row["Id"] = pair.Entity.Id;
pair.Row["Name"] = new T(pair.Entity.Name);
pair.Row["MainAlbumThumbnail"] = (
albumManager.GetAlbumImageWebPath(pair.Entity.Id, null, ProductAlbumImageType.Thumbnail));
pair.Row["Price"] = pair.Entity.MatchedDatas.GetPriceString();
pair.Row["Seller"] = seller == null ? null : seller.Username;
}
}
/// <summary>
/// 选择数据
/// </summary>
public void OnSelect(
StaticTableSearchRequest request, List <EntityToTableRow <Database.Article> > pairs)
{
foreach (var pair in pairs)
{
var author = pair.Entity.Author;
var lastClass = pair.Entity.Classes.OrderByDescending(c => c.Id).LastOrDefault();
pair.Row["Id"] = pair.Entity.Id;
pair.Row["Title"] = pair.Entity.Title;
pair.Row["Summary"] = pair.Entity.Summary;
pair.Row["Author"] = author == null ? null : author.Username;
pair.Row["AuthorId"] = author == null ? null : (long?)author.Id;
pair.Row["CreateTime"] = pair.Entity.CreateTime.ToClientTimeString();
pair.Row["LastClass"] = lastClass == null ? null : new T(lastClass.Name).ToString();
pair.Row["LastClassId"] = lastClass == null ? null : (long?)lastClass.Id;
pair.Row["Tags"] = pair.Entity.Tags.Select(t => new { t.Id, t.Name }).ToList();
}
}
/// <summary>
/// 过滤数据
/// </summary>
public void OnQuery(
StaticTableSearchRequest request, IDatabaseContext context, ref IQueryable <Database.Product> query)
{
// 按分类
var classId = request.Conditions.GetOrDefault <long?>("class");
if (classId != null)
{
query = query.Where(q => q.Classes.Any(c => c.Id == classId));
}
// 按标签
var tagId = request.Conditions.GetOrDefault <long?>("tag");
if (tagId != null)
{
query = query.Where(q => q.Tags.Any(t => t.Id == tagId));
}
// 按价格范围（这里不考虑货币）
var priceRange = request.Conditions.GetOrDefault <string>("price_range");
if (!string.IsNullOrEmpty(priceRange) && priceRange.Contains('~'))
{
var priceBounds = priceRange.Split('~');;
var lowerBound = priceBounds[0].ConvertOrDefault <decimal>();
var upperBound = priceBounds[1].ConvertOrDefault <decimal>();
query = query.Where(q => q.MatchedDatas.Any(d => d.Price != null && d.Price >= lowerBound));
if (upperBound > 0)
{
query = query.Where(q => q.MatchedDatas.Any(d => d.Price != null && d.Price <= upperBound));
}
}
// 按关键词
if (!string.IsNullOrEmpty(request.Keyword))
{
query = query.Where(q => q.Name.Contains(request.Keyword));
}
// 只显示未删除且允许显示的商品
var visibleStates = Application.Ioc.ResolveMany <IProductState>()
.Where(s => ProductStateTrait.For(s.GetType()).VisibleFromProductList)
.Select(s => s.State).ToList();
query = query.Where(q => !q.Deleted && visibleStates.Contains(q.State));
}
/// <summary>
/// 根据当前http请求获取搜索结果
/// 结果会按请求参数和当前登录用户缓存一定时间
/// </summary>
/// <returns></returns>
public virtual StaticTableSearchResponse GetArticleSearchResponseFromHttpRequest()
{
// 从缓存获取
var searchResponse = ArticleSearchResultCache.GetOrDefault(0);
if (searchResponse != null)
{
return(searchResponse);
}
// 从数据库获取
var configManager = Application.Ioc.Resolve <GenericConfigManager>();
var articleListSettings = configManager.GetData <ArticleListSettings>();
var searchRequest = StaticTableSearchRequest.FromHttpRequest(
articleListSettings.ArticlesPerPage);
var callbacks = new ArticleTableCallback().WithExtensions();
searchResponse = searchRequest.BuildResponseFromDatabase(callbacks);
// 保存到缓存中并返回
ArticleSearchResultCache.Put(0, searchResponse, ArticleSearchResultCacheTime);
return(searchResponse);
}
/// <summary>
/// 排序数据
/// </summary>
public override void OnSort(
StaticTableSearchRequest request, ref IQueryable <Product> query)
{
var order = request.Conditions.GetOrDefault <string>("order");
if (order == "best_sales")
{
// 最佳销量
// 商品插件中不处理这个排序，有需要请使用其他插件处理
query = query.OrderByDescending(q => q.Id);
}
else if (order == "lower_price")
{
// 更低价格
query = query.Select(
q => new { q, minPrice = q.MatchedDatas.Where(m => m.Price != null).Min(m => m.Price) })
.Where(q => q.minPrice != null).OrderBy(q => q.minPrice).Select(q => q.q);
}
else if (order == "higher_price")
{
// 更高价格
query = query.Select(
q => new { q, maxPrice = q.MatchedDatas.Where(m => m.Price != null).Max(m => m.Price) })
.Where(q => q.maxPrice != null).OrderByDescending(q => q.maxPrice).Select(q => q.q);
}
else if (order == "newest_on_sale")
{
// 最新上架
query = query.OrderByDescending(q => q.UpdateTime);
}
else
{
// 默认排序，先按显示顺序再按更新时间
query = query.OrderBy(q => q.DisplayOrder).ThenByDescending(q => q.UpdateTime);
}
}
/// <summary>
/// 选择需要的字段
/// </summary>
public abstract void OnSelect(
StaticTableSearchRequest request, IList <EntityToTableRow <TEntity> > pairs);
public override void OnSort(
StaticTableSearchRequest request, ref IQueryable <ExampleTable> query)
{
query = query.OrderByDescending(q => q.Id);
}
/// <summary>
/// 过滤数据
/// 默认不过滤数据
/// </summary>
public virtual void OnQuery(
StaticTableSearchRequest request, ref IQueryable <TEntity> query)
{
}
/// <summary>
/// 排序数据
/// </summary>
public override void OnSort(
StaticTableSearchRequest request, ref IQueryable <Article> query)
{
// 默认先按显示顺序再按更新时间排序
query = query.OrderBy(q => q.DisplayOrder).ThenByDescending(q => q.UpdateTime);
}
/// <summary>
/// 排序数据
/// </summary>
public void OnSort(
StaticTableSearchRequest request, IDatabaseContext context, ref IQueryable <Database.Article> query)
{
// 默认先按显示顺序再按更新时间排序
query = query.OrderBy(q => q.DisplayOrder).ThenByDescending(q => q.LastUpdated);
}
