public async Task <IActionResult> GetAllEventsAsync([FromQuery] PaginationQueryDto paginationQuery)
{
if (paginationQuery is null)
{
paginationQuery = new PaginationQueryDto();
}
return(Ok(await _eventService.GetEventsAsync(paginationQuery)));
}
public PaginationQueryDto QueryRunning(PaginationQueryInput input)
{
if (input == null)
{
throw new ArgumentNullException($"{nameof(input)} should not be null.");
}
PaginationQueryDto output = DbContext.Task.PageList <Core.Entities.Task, string, string>(input, d => d.IsRunning, d => d.Id);
output.Result = Mapper.Map <List <TaskDto> >(output.Result);
return(output);
}
private static void ValidatePaginationQuery(PaginationQueryDto paginationQuery, long totalEventsNumber)
{
if (paginationQuery.PageSize < 1)
{
throw new ServiceException(ExceptionMessage.Org.InvalidPaginationParams);
}
if (totalEventsNumber == 0 && paginationQuery.PageNumber == 0)
{
return;
}
if ((int)Math.Ceiling(totalEventsNumber / (double)paginationQuery.PageSize) < paginationQuery.PageNumber + 1)
{
throw new ServiceException(ExceptionMessage.Org.InvalidPaginationParams);
}
}
public PaginationQueryDto Find(PaginationQueryInput input)
{
if (input == null)
{
throw new ArgumentNullException($"{nameof(input)} should not be null.");
}
var output = new PaginationQueryDto
{
Page = input.Page.Value,
Size = input.Size.Value
};
var taskId = long.Parse(input.GetFilterValue("taskid"));
var taskHistoryOutput = DbContext.TaskHistory.PageList(input, a => a.TaskId == taskId, t => t.CreationTime);
output.Total = taskHistoryOutput.Total;
var taskHistories = (List <Domain.Entities.TaskHistory>)taskHistoryOutput.Result;
List <Domain.Entities.TaskStatus> statuses;
if (taskHistories.Count > 0)
{
var identities = taskHistories.Select(r => r.Identity);
statuses = DbContext.TaskStatus.Where(a => identities.Contains(a.Identity)).ToList();
}
else
{
statuses = new List <Domain.Entities.TaskStatus>(0);
}
var result = new List <PaginationQueryTaskHistoryDto>(taskHistories.Count);
var statusOutputs = Mapper.Map <List <TaskStatusDto> >(statuses);
foreach (var item in taskHistories)
{
result.Add(new PaginationQueryTaskHistoryDto
{
Identity = item.Identity,
CreationTime = item.CreationTime.ToString("yyyy/MM/dd HH:mm:ss"),
Statuses = statusOutputs.Where(a => a.Identity == item.Identity).ToList()
});
}
output.Result = result;
return(output);
}
public static PaginationQueryDto PageList <TEntity, TKey>(this DbSet <TEntity> dbSet, PaginationQueryInput input,
Expression <Func <TEntity, bool> > where = null,
Expression <Func <TEntity, TKey> > orderyBy = null) where TEntity : Entity <long>
{
input.Validate();
PaginationQueryDto output = new PaginationQueryDto();
IQueryable <TEntity> entities = dbSet.AsQueryable();
if (where != null)
{
entities = entities.Where(where);
}
output.Total = entities.Count();
if (orderyBy == null)
{
if (input.SortByDesc)
{
entities = entities.OrderByDescending(e => e.Id).Skip((input.Page.Value - 1) * input.Size.Value).Take(input.Size.Value);
}
else
{
entities = entities.Skip((input.Page.Value - 1) * input.Size.Value).Take(input.Size.Value);
}
}
else
{
if (input.SortByDesc)
{
entities = entities.OrderByDescending(orderyBy).Skip((input.Page.Value - 1) * input.Size.Value).Take(input.Size.Value);
}
else
{
entities = entities.OrderBy(orderyBy).Skip((input.Page.Value - 1) * input.Size.Value).Take(input.Size.Value);
}
}
output.Page = input.Page.Value;
output.Size = input.Size.Value;
output.Result = entities.ToList();
return(output);
}
public async Task <PaginatedResponse <EventDto> > GetEventsAsync(PaginationQueryDto paginationQuery)
{
var totalEventsNumber = await _eventRepository.CountAsync();
ValidatePaginationQuery(paginationQuery, totalEventsNumber);
var events = new List <Event>();
if (totalEventsNumber > 0)
{
var skip = paginationQuery.PageNumber * paginationQuery.PageSize;
events.AddRange(await _eventRepository.GetAsync(skip, paginationQuery.PageSize));
}
var pageSize = paginationQuery.PageSize > totalEventsNumber ? (int)totalEventsNumber : paginationQuery.PageSize;
var totalPages = (pageSize < 1) ? 0 : (int)Math.Ceiling(totalEventsNumber / (double)pageSize);
return(new PaginatedResponse <EventDto>(
_mapper.Map <IEnumerable <EventDto> >(events),
paginationQuery.PageNumber,
totalPages,
totalEventsNumber
));
}
