/// <summary>
///
/// </summary>
/// <param name="option"></param>
/// <returns></returns>
public static DynamicFilterInfo ToDynamicFilter(this QueryPageOptions option)
{
var ret = new DynamicFilterInfo()
{
Filters = new List <DynamicFilterInfo>()
};
foreach (var filter in option.Filters.Concat(option.Searchs))
{
var item = new DynamicFilterInfo()
{
Filters = new List <DynamicFilterInfo>()
};
var actions = filter.GetFilterConditions();
foreach (var f in actions)
{
item.Logic = f.FilterLogic.ToDynamicFilterLogic();
item.Filters.Add(new DynamicFilterInfo()
{
Field = f.FieldKey,
Value = f.FieldValue,
Operator = f.FilterAction.ToDynamicFilterOperator()
});
}
ret.Filters.Add(item);
}
return(ret);
}
/// <summary>
///
/// </summary>
/// <param name="items"></param>
/// <param name="options"></param>
/// <returns></returns>
protected Task <QueryData <Foo> > FooQueryAsync(IEnumerable <Foo> items, QueryPageOptions options)
{
if (!string.IsNullOrEmpty(SearchModel.Name))
{
items = items.Where(item => item.Name?.Contains(SearchModel.Name, StringComparison.OrdinalIgnoreCase) ?? false);
}
if (!string.IsNullOrEmpty(SearchModel.Address))
{
items = items.Where(item => item.Address?.Contains(SearchModel.Address, StringComparison.OrdinalIgnoreCase) ?? false);
}
if (options.Searchs.Any())
{
// 针对 SearchText 进行模糊查询
items = items.Where(options.Searchs.GetFilterFunc <Foo>(FilterLogic.Or));
}
else
{
if (!string.IsNullOrEmpty(options.SearchText))
{
items = items.Where(item => (item.Name?.Contains(options.SearchText) ?? false) ||
(item.Address?.Contains(options.SearchText) ?? false));
}
}
// 过滤
var isFiltered = false;
if (options.Filters.Any())
{
items = items.Where(options.Filters.GetFilterFunc <Foo>());
isFiltered = true;
}
// 排序
var isSorted = false;
if (!string.IsNullOrEmpty(options.SortName))
{
// 外部未进行排序，内部自动进行排序处理
var invoker = SortLambdaCache.GetOrAdd(typeof(Foo), key => items.GetSortLambda().Compile());
items = invoker(items, options.SortName, options.SortOrder);
isSorted = true;
}
// 设置记录总数
var total = items.Count();
// 内存分页
items = items.Skip((options.PageIndex - 1) * options.PageItems).Take(options.PageItems).ToList();
return(Task.FromResult(new QueryData <Foo>()
{
Items = items,
TotalCount = total,
IsSorted = isSorted,
IsFiltered = isFiltered,
IsSearch = !string.IsNullOrEmpty(SearchModel.Name) || !string.IsNullOrEmpty(SearchModel.Address)
}));
}
private Task <QueryData <Foo> > OnSearchModelQueryAsync(QueryPageOptions options)
{
// 自定义了 SearchModel
IEnumerable <Foo> items = Items;
// 设置记录总数
var total = items.Count();
if (!string.IsNullOrEmpty(SearchModel.Name))
{
items = items.Where(i => i.Name == SearchModel.Name);
}
if (!string.IsNullOrEmpty(SearchModel.Address))
{
items = items.Where(i => i.Address == SearchModel.Address);
}
// 内存分页
items = items.Skip((options.PageIndex - 1) * options.PageItems).Take(options.PageItems).ToList();
return(Task.FromResult(new QueryData <Foo>()
{
Items = items,
TotalCount = total,
IsSorted = true,
IsFiltered = true,
IsSearch = true,
IsAdvanceSearch = true
}));
}
private Task <QueryData <Foo> > OnSearchQueryAsync(QueryPageOptions options)
{
var items = Items.AsEnumerable();
if (!string.IsNullOrEmpty(options.SearchText))
{
// 针对 SearchText 进行模糊查询
items = items.Where(i => (i.Address ?? "").Contains(options.SearchText) ||
(i.Name ?? "").Contains(options.SearchText));
}
// 设置记录总数
var total = items.Count();
// 内存分页
items = items.Skip((options.PageIndex - 1) * options.PageItems).Take(options.PageItems).ToList();
return(Task.FromResult(new QueryData <Foo>()
{
Items = items,
TotalCount = total,
IsSorted = true,
IsFiltered = true,
IsSearch = true
}));
}
protected async Task <QueryData <UserDto> > OnQueryAsync(QueryPageOptions options)
{
var result = await UserService.GetUserPage(new UserQueryDto
{
CurrentPage = options.PageIndex,
PageSize = options.PageItems,
Username = SearchModel.Username,
Enabled = SearchModel.Enabled,
});
if (result.status.code == ResultCode.Success)
{
foreach (var item in result.custom.Data)
{
item.EnabledAddOrEdit = item.Enabled.Value;
}
return(new QueryData <UserDto>
{
Items = result.custom.Data,
TotalCount = result.custom.TotalCount,
IsSorted = false,
IsFiltered = false
});
}
return(null);
}
private Task <QueryData <EditFooTree> > OnQueryAsync(QueryPageOptions _)
{
return(Task.FromResult(new QueryData <EditFooTree>()
{
Items = AllItems.Where(f => f.ParentId == 0)
}));
}
/// <summary>
/// 查询方法
/// </summary>
/// <param name="option"></param>
/// <returns></returns>
public override async Task <QueryData <TModel> > QueryAsync(QueryPageOptions option)
{
var ret = new QueryData <TModel>()
{
IsSorted = true,
IsFiltered = true,
IsSearch = true
};
if (option.IsPage)
{
var items = await _db.PageAsync <TModel>(option.PageIndex, option.PageItems, option.Filters.Concat(option.Searchs), option.SortName, option.SortOrder);
ret.TotalCount = int.Parse(items.TotalItems.ToString());
ret.Items = items.Items;
}
else
{
var items = await _db.FetchAsync <TModel>(option.Filters.Concat(option.Searchs), option.SortName, option.SortOrder);
ret.TotalCount = items.Count;
ret.Items = items;
}
return(ret);
}
protected async Task <QueryData <UserRoleDto> > OnQueryAsync(QueryPageOptions options)
{
var result = await RoleService.GetUserRole(new UserRoleDto
{
UserId = UserDto.UserId,
CurrentPage = options.PageIndex,
PageSize = options.PageItems,
RoleName = SearchModel.RoleName,
IsHaveRole = SearchModel.IsHaveRole
});
if (result.status.code == ResultCode.Success)
{
result.custom.Data.ForEach(x => {
x.IsHaveRoleView = x.IsHaveRole.Value;
});
return(new QueryData <UserRoleDto>
{
Items = result.custom.Data,
TotalCount = result.custom.TotalCount,
IsSorted = false,
IsFiltered = false
});
}
return(null);
}
private Task <QueryData <BindItem> > OnRefreshQueryAsync(QueryPageOptions options)
{
// 设置记录总数
var total = AutoItems.Count();
AutoItems.Insert(0, new BindItem()
{
Id = total++,
Name = $"张三 {total:d4}",
DateTime = DateTime.Now.AddDays(total - 1),
Address = $"上海市普陀区金沙江路 {random.Next(1000, 2000)} 弄",
Count = random.Next(1, 100),
Complete = random.Next(1, 100) > 50,
Education = random.Next(1, 100) > 50 ? EnumEducation.Primary : EnumEducation.Middel
});
if (AutoItems.Count > 10)
{
AutoItems.RemoveRange(10, 1);
total = 10;
}
// 内存分页
var items = AutoItems.Skip((options.PageIndex - 1) * options.PageItems).Take(options.PageItems).ToList();
return(Task.FromResult(new QueryData <BindItem>()
{
Items = items,
TotalCount = total
}));
}
/// <summary>
/// 查询方法
/// </summary>
/// <param name="options"></param>
protected override QueryData <Group> Query(QueryPageOptions options)
{
var data = GroupHelper.Retrieves();
if (!string.IsNullOrEmpty(QueryModel.GroupName))
{
data = data.Where(d => d.GroupName.Contains(QueryModel.GroupName, StringComparison.OrdinalIgnoreCase));
}
if (!string.IsNullOrEmpty(QueryModel.Description))
{
data = data.Where(d => d.Description != null && d.Description.Contains(QueryModel.Description, StringComparison.OrdinalIgnoreCase));
}
if (!string.IsNullOrEmpty(options.SearchText))
{
data = data.Where(d => d.GroupName.Contains(options.SearchText, StringComparison.OrdinalIgnoreCase) || (d.Description ?? "").Contains(options.SearchText, StringComparison.OrdinalIgnoreCase));
}
// sort
data = options.SortName switch
{
nameof(Group.GroupName) => options.SortOrder == SortOrder.Asc ? data.OrderBy(d => d.GroupName) : data.OrderByDescending(d => d.GroupName),
nameof(Group.GroupCode) => options.SortOrder == SortOrder.Asc ? data.OrderBy(d => d.GroupCode) : data.OrderByDescending(d => d.GroupCode),
nameof(Group.Description) => options.SortOrder == SortOrder.Asc ? data.OrderBy(d => d.Description) : data.OrderByDescending(d => d.Description),
_ => data
};
var totalCount = data.Count();
var items = data.Skip((options.PageIndex - 1) * options.PageItems).Take(options.PageItems);
return(new QueryData <Group>()
{
Items = items, TotalCount = totalCount, PageIndex = options.PageIndex, PageItems = options.PageItems
});
}
private Task <QueryData <ClientRedirectUriEditDto> > OnRedirectQuery(QueryPageOptions options)
{
return(Task.FromResult(new QueryData <ClientRedirectUriEditDto>
{
Items = ClientEditDto.RedirectUris,
TotalCount = ClientEditDto.RedirectUris.Count
}));
}
private Task <QueryData <ClientScopeEditDto> > OnApiQuery(QueryPageOptions options)
{
return(Task.FromResult(new QueryData <ClientScopeEditDto>
{
Items = ClientEditDto.AllowedScopes,
TotalCount = ClientEditDto.AllowedScopes.Count
}));
}
private Task <QueryData <ClientSecretEditDto> > OnSecretQuery(QueryPageOptions options)
{
return(Task.FromResult(new QueryData <ClientSecretEditDto>
{
Items = ClientEditDto.ClientSecrets,
TotalCount = ClientEditDto.ClientSecrets.Count
}));
}
private Task <QueryData <ClientCorsOriginEditDto> > OnCorsQuery(QueryPageOptions options)
{
return(Task.FromResult(new QueryData <ClientCorsOriginEditDto>
{
Items = ClientEditDto.AllowedCorsOrigins,
TotalCount = ClientEditDto.AllowedCorsOrigins.Count
}));
}
/// <summary>
/// QueryData 方法
/// </summary>
protected QueryData <OnlineUser> QueryData(QueryPageOptions options)
{
var data = OnlineUSers?.OnlineUsers ?? new OnlineUser[0];
return(new QueryData <OnlineUser>()
{
Items = data,
TotalCount = data.Count()
});
}
private Task <QueryData <Product> > OnQueryAsync(QueryPageOptions options)
{
var items = Products.Skip((options.PageIndex - 1) * options.PageItems).Take(options.PageItems);
return(Task.FromResult(new QueryData <Product>()
{
Items = items,
TotalCount = Products.Count()
}));
}
/// <summary>
/// QueryPageOptions 转换为 PaginationOption 方法
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public static PaginationOption ToPaginationOption(this QueryPageOptions options)
{
return(new PaginationOption()
{
Limit = options.PageItems,
Offset = (options.PageIndex - 1) * options.PageItems,
Order = options.SortOrder == SortOrder.Unset ? "" : options.SortOrder.ToString(),
Sort = options.SortName,
Search = options.SearchText
});
}
private async Task <QueryData <Foo> > OnQueryAsync(QueryPageOptions options)
{
await Task.Delay(200);
var items = Items.Skip(options.StartIndex).Take(options.PageItems);
return(new QueryData <Foo>()
{
Items = items,
TotalCount = Items.Count
});
}
/// <summary>
/// 資料查詢方法
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
protected QueryData <User> Query(QueryPageOptions options)
{
var data = UserHelper.RetrieveNewUsers();
return(new QueryData <User>()
{
Items = data,
PageIndex = 1,
PageItems = data.Count(),
TotalCount = data.Count()
});
}
/// <summary>
/// QueryData 方法
/// </summary>
protected QueryData <ICacheItem> QueryData(QueryPageOptions options)
{
var data = CacheManager.ToList();
var pageItems = data.Count();
return(new QueryData <ICacheItem>()
{
Items = data,
PageItems = pageItems,
TotalCount = pageItems
});
}
/// <summary>
/// 查询方法
/// </summary>
/// <param name="option"></param>
/// <returns></returns>
public override Task <QueryData <TModel> > QueryAsync(QueryPageOptions option)
{
FetchAsync(option);
var ret = new QueryData <TModel>()
{
TotalCount = (int)(TotalCount ?? 0),
Items = Items
};
Options = option;
return(Task.FromResult(ret));
}
/// <summary>
/// 查询方法
/// </summary>
/// <param name="option"></param>
/// <returns></returns>
public override async Task <QueryData <TModel> > QueryAsync(QueryPageOptions option)
{
// TODO: 未做分页处理
var items = await _db.FetchAsync <TModel>();
var ret = new QueryData <TModel>()
{
TotalCount = items.Count,
Items = items
};
return(ret);
}
private async Task <QueryData <TItem> > InternalOnQueryAsync(QueryPageOptions options)
{
QueryData <TItem>?ret = null;
if (OnQueryAsync != null)
{
ret = await OnQueryAsync(options);
}
else
{
var d = DataService ?? InjectDataService;
ret = await d.QueryAsync(options);
}
return(ret);
}
/// <summary>
/// 查询方法
/// </summary>
/// <param name="option"></param>
/// <returns></returns>
public override Task <QueryData <TModel> > QueryAsync(QueryPageOptions option)
{
//TODO: 是否能够通过参数判断是否进行分页
var items = _db.Select <TModel>()
.Count(out var count)
.Page(option.PageIndex, option.PageItems)
.ToList();
var ret = new QueryData <TModel>()
{
TotalCount = (int)count,
Items = items
};
return(Task.FromResult(ret));
}
private Task <QueryData <Foo> > OnQueryProductAsync(QueryPageOptions options)
{
var items = ProductSelectItems;
var total = items.Count;
// 内存分页
items = items.Skip((options.PageIndex - 1) * options.PageItems).Take(options.PageItems).ToList();
return(Task.FromResult(new QueryData <Foo>()
{
Items = items,
TotalCount = total,
}));
}
public Task <QueryData <Foo> > QueryAsync(QueryPageOptions option)
{
var foos = Foo.GenerateFoo(Localizer, 2);
var ret = new QueryData <Foo>()
{
Items = foos,
TotalCount = 2,
IsAdvanceSearch = true,
IsFiltered = true,
IsSearch = true,
IsSorted = true
};
return(Task.FromResult(ret));
}
private Task <QueryData <Foo> > OnQueryAsync(QueryPageOptions options)
{
IEnumerable <Foo> items = Items;
// 设置记录总数
var total = items.Count();
// 内存分页
items = items.Skip((options.PageIndex - 1) * options.PageItems).Take(options.PageItems).ToList();
return(Task.FromResult(new QueryData <Foo>()
{
Items = items,
TotalCount = total
}));
}
/// <summary>
/// 查询操作方法
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public override Task <QueryData <TModel> > QueryAsync(QueryPageOptions options)
{
// 此处代码实战中不可用，仅仅为演示而写
if (Items == null || Items.Count == 0)
{
Items = TablesBase.GenerateItems().Cast <TModel>().ToList();
}
var total = Items.Count;
return(Task.FromResult(new QueryData <TModel>()
{
Items = Items.Skip((options.PageIndex - 1) * options.PageItems).Take(options.PageItems).ToList(),
TotalCount = total
}));
}
private void FetchAsync(QueryPageOptions options)
{
#if DEBUG
initTestDatas();
#endif
//.WhereDynamicFilter(dyfilter)
//两种版本 var lambda = MakeWhereLambda(option, out var isSerach);
var dynamicFilterInfo = MakeDynamicFilterInfo(options, out var isSerach);
if (TotalCount != null && !isSerach && options.PageItems != Options.PageItems && TotalCount <= Options.PageItems)
{
//当选择的每页显示数量大于总数时，强制认为是一页
//无搜索,并且总数<=分页总数直接使用内存排序和搜索
Console.WriteLine($"无搜索,分页数相等{ options.PageItems}/{ Options.PageItems},直接使用内存排序和搜索");
}
else
{
var fsql_select = _db.Select <TModel>();
if (isSerach)
{
fsql_select = fsql_select.WhereDynamicFilter(dynamicFilterInfo);
}
fsql_select = fsql_select.OrderByPropertyNameIf(options.SortOrder != SortOrder.Unset, options.SortName, options.SortOrder == SortOrder.Asc);
//分页==1才获取记录总数量,省点性能
long count = 0;
if (options.PageIndex == 1)
{
fsql_select = fsql_select.Count(out count);
}
//判断是否分页
if (options.IsPage)
{
fsql_select = fsql_select.Page(options.PageIndex, options.PageItems);
}
Items = fsql_select.ToList();
TotalCount = options.PageIndex == 1 ? count : TotalCount;
}
}
private Task <QueryData <Foo> > OnQueryAsync(QueryPageOptions options)
{
// 设置记录总数
var total = Items.Count;
// 内存分页
var items = Items.Skip((options.PageIndex - 1) * options.PageItems).Take(options.PageItems).ToList();
return(Task.FromResult(new QueryData <Foo>()
{
Items = items,
TotalCount = total,
IsSorted = true,
IsFiltered = true,
IsSearch = true
}));
}
