/// <summary>
/// 获取操作功能分页
/// </summary>
/// <param name="query">查询对象</param>
/// <returns></returns>
IPaging <Operation> GetPaging(IQuery query)
{
var operationPaging = operationRepository.GetPaging(query);
var operationList = LoadOtherData(operationPaging, query);
return(Pager.Create <Operation>(operationPaging.Page, operationPaging.PageSize, operationPaging.TotalCount, operationList));
}
/// <summary>
/// 获取权限分页
/// </summary>
/// <param name="query">查询对象</param>
/// <returns></returns>
public IPaging <Authority> GetAuthorityPaging(IQuery query)
{
var authorityPaging = authRepository.GetPaging(query);
var authorityList = LoadOtherObjectData(authorityPaging, query);
return(Pager.Create <Authority>(authorityPaging.Page, authorityPaging.PageSize, authorityPaging.TotalCount, authorityList));
}
/// <summary>
/// Query data paging
/// </summary>
/// <typeparam name="T">Data type</typeparam>
/// <param name="command">Command</param>
/// <returns>Return data paging</returns>
public async Task <PagingInfo <T> > QueryPagingAsync <T>(ICommand command) where T : BaseEntity <T>, new()
{
var servers = GetServers(command);
VerifyServerProvider(servers.Select(c => c.ServerType));
#region Single server
if (servers.Count == 1)
{
return(await SingleServerPagingAsync <T>(servers[0], command).ConfigureAwait(false));
}
#endregion
#region Multiple server
int pageSize = command.Query.PagingInfo.PageSize;
int page = command.Query.PagingInfo.Page;
command.Query.PagingInfo.PageSize = page * pageSize;
command.Query.PagingInfo.Page = 1;
Task <PagingInfo <T> >[] pagingTasks = new Task <PagingInfo <T> > [servers.Count];
int serverIndex = 0;
foreach (var server in servers)
{
pagingTasks[serverIndex] = SingleServerPagingAsync <T>(server, command);
serverIndex++;
}
var allPagings = await Task.WhenAll(pagingTasks).ConfigureAwait(false);
IEnumerable <T> datas = Array.Empty <T>();
long totalCount = 0;
foreach (var paging in allPagings)
{
if (paging == null)
{
continue;
}
totalCount += paging.TotalCount;
if (!paging.Items.IsNullOrEmpty())
{
datas = datas.Union(paging.Items);
}
}
if (command.Query != null)
{
datas = command.Query.Sort(datas);
}
if (datas.Count() > pageSize)
{
datas = datas.Skip((page - 1) * pageSize).Take(pageSize);
}
command.Query.PagingInfo.PageSize = pageSize;
command.Query.PagingInfo.Page = page;
return(Pager.Create(page, pageSize, totalCount, datas));
#endregion
}
public void Pager__PageSizeLargerThanItems_Expect1Page_Success()
{
var pager = Pager <string> .Create(10, new List <string> {
"", "", "", ""
});
Assert.True(pager.TotalPages == 1);
}
public void Pager_ItemsMatchPageSize_TotalPages1_Success()
{
var pager = Pager <string> .Create(3, new List <string> {
"", "", ""
});
Assert.True(pager.TotalPages == 1);
}
public void Pager_Create_PagesRemaining_Success()
{
var pager = Pager <string> .Create(3, new List <string> {
"", "", "", ""
});
Assert.True(pager.PagesRemaining == 2);
}
public void Pager_CurrentPageIsNull_AfterCreate_Success()
{
var pager = Pager <string> .Create(pageSize : 3, collection : new List <string> {
"", "", "", ""
});
Assert.Null(pager.CurrentPage);
}
public void Pager__TotalPages2_Success()
{
var pager = Pager <string> .Create(3, new List <string> {
"", "", "", ""
});
Assert.True(pager.TotalPages == 2);
}
public void Pager__CreatesPartialPage_Success()
{
var pager = Pager <string> .Create(3, new List <string> {
"", "", "", ""
});
var nextPage = pager.NextPage;
Assert.True(nextPage.Items.Count == 1);
}
/// <summary>
/// Query paging with single server
/// </summary>
/// <typeparam name="T">Data type</typeparam>
/// <param name="command">Command</param>
/// <returns>Return data paging</returns>
async Task <PagingInfo <T> > SingleServerPagingAsync <T>(DatabaseServer server, ICommand command) where T : BaseEntity <T>, new()
{
var provider = DataManager.GetDatabaseProvider(server.ServerType);
IEnumerable <T> datas = await provider.QueryPagingAsync <T>(server, command).ConfigureAwait(false);
if (datas.IsNullOrEmpty())
{
return(Pager.Empty <T>());
}
return(Pager.Create(command.Query.PagingInfo.Page, command.Query.PagingInfo.PageSize, datas.ElementAt(0).GetTotalCount(), datas));
}
public void Pager__GetNext_GetNextPageEqualsNextPage_Success()
{
var pager = Pager <string> .Create(3, new List <string> {
"", "", "", ""
});
var nextPage = pager.NextPage;
var getNextPage = pager.GetNextPage();
Assert.True(nextPage == getNextPage);
}
public void Pager__GetNextOnLastPage_NextPageNull_Success()
{
var pager = Pager <string> .Create(3, new List <string> {
"", "", "", ""
});
var page1 = pager.GetNextPage();
var page2 = pager.GetNextPage();
Assert.Null(pager.NextPage);
}
/// <summary>
/// Get relation data paging
/// </summary>
/// <param name="query">Query object</param>
/// <returns>Return relation data paging</returns>
public virtual async Task <IPaging <Tuple <TFirstModel, TSecondModel> > > ExecuteGetPagingAsync(IQuery query)
{
var entityPaging = await repositoryWarehouse.GetPagingAsync(query).ConfigureAwait(false);
if (entityPaging.IsNullOrEmpty())
{
return(Pager.Empty <Tuple <TFirstModel, TSecondModel> >());
}
var datas = entityPaging.Select(c => CreateRelationDataByEntity(c));
return(Pager.Create(entityPaging.Page, entityPaging.PageSize, entityPaging.TotalCount, datas));
}
public void Pager_PreviousPage_Success()
{
var pager = Pager <string> .Create(3, new List <string> {
"", "", "", ""
});
var page1 = pager.GetNextPage();
var page2 = pager.GetNextPage();
var prevPage = pager.PreviousPage;
Assert.True(page1 == prevPage);
}
/// <summary>
/// Get data paging
/// </summary>
/// <param name="query">Query object</param>
/// <returns>Return data paging</returns>
public sealed override async Task <IPaging <TModel> > GetPagingAsync(IQuery query)
{
var newQuery = RepositoryManager.HandleQueryObjectBeforeExecute(query, QueryUsageScene.Query, AppendQueryCondition);
var paging = await GetDataPagingAsync(newQuery).ConfigureAwait(false);
IEnumerable <TModel> datas = paging;
QueryCallback(newQuery, true, datas);
RepositoryEventBus.PublishQuery(GetType(), datas, newQuery, result =>
{
QueryEventResult <TModel> queryResult = result as QueryEventResult <TModel>;
if (queryResult != null)
{
datas = queryResult.Datas;
}
});
RepositoryManager.HandleQueryObjectAfterExecute(query, newQuery, QueryUsageScene.Query);
return(Pager.Create(paging.Page, paging.PageSize, paging.TotalCount, datas));
}
/// <summary>
/// Merge paging
/// </summary>
/// <typeparam name="TEntity">Entity type</typeparam>
/// <param name="originalPaging">Original paging</param>
/// <param name="query">Query object</param>
/// <returns>Return the newest data paging</returns>
public static IPaging <TEntity> MergePaging <TEntity>(IPaging <TEntity> originalPaging, IQuery query) where TEntity : BaseEntity <TEntity>, new()
{
if (originalPaging == null)
{
originalPaging = Pager.Empty <TEntity>();
}
var totalCount = originalPaging.TotalCount;
var dataCount = originalPaging.Count();
var datas = Merge(originalPaging, query, true);
var newDataCount = datas.Count;
var diffCount = newDataCount - dataCount;
totalCount += diffCount;
if (newDataCount > originalPaging.PageSize)
{
datas = datas.Take(originalPaging.PageSize).ToList();
}
return(Pager.Create <TEntity>(originalPaging.Page, originalPaging.PageSize, totalCount, datas));
}
public void Pager_Create_NullList_PagesRemaining0_Success()
{
var pager = Pager <string> .Create(3, null);
Assert.True(pager.PagesRemaining == 0);
}
public void Pager_Create_NullList_TotalPages0_Success()
{
var pager = Pager <string> .Create(3, null);
Assert.True(pager.TotalPages == 0);
}
/// <summary>
/// Query data paging
/// </summary>
/// <typeparam name="T">Data type</typeparam>
/// <param name="command">Command</param>
/// <returns>Return datas</returns>
internal static async Task <IPaging <T> > QueryPagingAsync <T>(ICommand command) where T : BaseEntity <T>, new()
{
if (command.Query?.PagingInfo == null)
{
throw new EZNEWException($"Paging information is not set");
}
var groupExecutors = GroupCommandByExecutor(new List <ICommand>(1)
{
command
});
if (groupExecutors == null || groupExecutors.Count <= 0)
{
return(Pager.Empty <T>());
}
#region Single executor
if (groupExecutors.Count == 1)
{
return(await groupExecutors.First().Value.Item1.QueryPagingAsync <T>(command).ConfigureAwait(false));
}
#endregion
#region Multiple executors
int pageSize = command.Query.PagingInfo.PageSize;
int page = command.Query.PagingInfo.Page;
command.Query.PagingInfo.PageSize = page * pageSize;
command.Query.PagingInfo.Page = 1;
//Paging task
Task <IPaging <T> >[] pagingTasks = new Task <IPaging <T> > [groupExecutors.Count];
var groupIndex = 0;
foreach (var groupExecutor in groupExecutors)
{
pagingTasks[groupIndex] = groupExecutor.Value.Item1.QueryPagingAsync <T>(command);
groupIndex++;
}
var allPagings = await Task.WhenAll(pagingTasks).ConfigureAwait(false);
IEnumerable <T> datas = Array.Empty <T>();
long totalCount = 0;
foreach (var paging in allPagings)
{
totalCount += paging.TotalCount;
datas = datas.Union(paging);
}
if (command.Query != null)
{
datas = command.Query.Sort(datas);
}
if (datas.Count() > pageSize)
{
datas = datas.Skip((page - 1) * pageSize).Take(pageSize);
}
command.Query.PagingInfo.PageSize = pageSize;
command.Query.PagingInfo.Page = page;
return(Pager.Create(page, pageSize, totalCount, datas));
#endregion
}
