public async Task <IEnumerable <MovieEntity> > GetMoviesByFilters(PaginationDto pagination)
{
var property = TypeDescriptor.GetProperties(typeof(MovieEntity)).Find(pagination.SortBy, true);
if (pagination.Filter == 2)
{
var query = pagination.Order == "Desc"
? FindAll().OrderByDescending(a => property.GetValue(a))
: FindAll().OrderBy(a => property.GetValue(a));
return(await query
.Skip((pagination.PageNumber - 1) *pagination.PageSize)
.Take(pagination.PageSize)
.ToListAsync());
}
else
{
var query = pagination.Order == "Desc"
? FindByCondition(p => p.Availability == pagination.Filter).OrderByDescending(a => property.GetValue(a))
: FindByCondition(p => p.Availability == pagination.Filter).OrderBy(a => property.GetValue(a));
return(await query
.Skip((pagination.PageNumber - 1) *pagination.PageSize)
.Take(pagination.PageSize)
.ToListAsync());
}
}
public PaginationDto GetListCustomersPage(int skip, int take, string filterFirstName, string filterLastName,
string filterAccountNumber, decimal filterSumTotalDueHigher, decimal filterSumTotalDueLower)
{
try
{
var paginationModel = _customerRepository.GetCustomersPage((skip - 1) * take, take, filterFirstName,
filterLastName, filterAccountNumber, filterSumTotalDueHigher, filterSumTotalDueLower);
var paginationDto = new PaginationDto(paginationModel);
foreach (var customer in paginationModel.CustomerItemList)
{
var customerModel = new CustomerDto(customer)
{
SumTotalDue = customer.SalesOrderHeader.Sum(s => s.TotalDue)
};
paginationDto.CustomerList.Add(customerModel);
}
return(paginationDto);
}
catch (Exception e)
{
_logger.LogDebug("get list customers", e);
throw new ApiException(e);
}
}
/// <summary>
/// Gets list object of the table LastLogin.
/// </summary>
/// <param name="paginationDto">Attributes to apply the pagination.</param>
/// <param name="listFilterLastLogin">List that contains the DTOs from LastLogin table that filter the query.</param>
/// <returns>List object of the table LastLogin.</returns>
/// <author>Mauricio Suárez.</author>
public List <LastLoginDto> GetLastLogin(PaginationDto paginationDto, LastLoginDto dtoLastLogin)
{
List <LastLoginDto> listFilterLastLogin = new List <LastLoginDto>();
listFilterLastLogin.Add(dtoLastLogin);
return(this.ExecuteGetLastLogin(paginationDto, listFilterLastLogin));
}
public void ShouldPaginateResults(int skip, int take)
{
PaginationDto pagination = new PaginationDto
{
Skip = skip,
Take = take
};
PersonOrderingDto ordering = new PersonOrderingDto();
var paginatedResult = _peopleRepository.GetAllWithPaginationAndFiltering("", ordering, pagination);
var results = paginatedResult.Results.ToList();
int expectedResultCount;
if (pagination.Skip >= 5)
{
expectedResultCount = 0;
}
else if (pagination.Skip + pagination.Take > 5)
{
expectedResultCount = 5 - pagination.Skip;
}
else
{
expectedResultCount = pagination.Take;
}
Assert.Equal(expectedResultCount, results.Count);
for (int i = 0; i < results.Count; i++)
{
Assert.Equal(i + skip + 1, results[i].ID);
}
}
/// <summary>
/// Gets list object of the table ApplicationUserRole.
/// </summary>
/// <param name="paginationDto">Attributes to apply the pagination.</param>
/// <param name="listFilterApplicationUserRole">List that contains the DTOs from ApplicationUserRole table that filter the query.</param>
/// <returns>List object of the table ApplicationUserRole.</returns>
/// <author>Mauricio Suárez.</author>
public List <ApplicationUserRoleDto> GetApplicationUserRole(PaginationDto paginationDto, ApplicationUserRoleDto dtoApplicationUserRole)
{
List <ApplicationUserRoleDto> listFilterApplicationUserRole = new List <ApplicationUserRoleDto>();
listFilterApplicationUserRole.Add(dtoApplicationUserRole);
return(this.ExecuteGetApplicationUserRole(paginationDto, listFilterApplicationUserRole));
}
public ActionResult <CollectionResourceDto> GetPets(
[FromQuery] PetsResourceParameters resourceParameters)
{
if (!_propertyMappingService.ValidMappingExistsFor <PetDto, Pet>(resourceParameters.OrderBy))
{
throw new AppException(nameof(resourceParameters.OrderBy));
}
if (!_propertyCheckerService.TypeHasProperties <PetDto>(resourceParameters.Fields))
{
throw new AppException(nameof(resourceParameters.Fields));
}
var itemsFromRepo = _unitOfWork.Pets.Get(resourceParameters, Account);
var paginationMetadata = new PaginationDto
(
itemsFromRepo.TotalCount,
itemsFromRepo.PageSize,
itemsFromRepo.CurrentPage,
itemsFromRepo.TotalPages
);
var shapedItems = _mapper.Map <IEnumerable <PetDto> >(itemsFromRepo)
.ShapeData(resourceParameters.Fields);
var collectionResource = new CollectionResourceDto(shapedItems, paginationMetadata);
return(Ok(collectionResource));
}
public async Task <IActionResult> GetMovies([FromQuery] PaginationDto pagination)
{
var top = 6;
var today = DateTime.Today;
var upcomingRelease = await _context.Movies.Where(x => x.ReleaseDate < today).OrderBy(x => x.ReleaseDate)
.Take(top).ToListAsync();
var inTheaters = await _context.Movies.Where(x => x.InTheaters).Take(top).ToListAsync();
var result = new IndexMoviePageDto()
{
InTheaters = _mapper.Map <List <MovieDto> >(inTheaters),
UpcomingRelease = _mapper.Map <List <MovieDto> >(upcomingRelease)
};
return(Ok(result));
/*//IQueryable Movie
* IQueryable<Movie> queryable = _context.Movies;
*
* //Save Count Page To Header
* await HttpContext.InsertPaginationParametersInResponse(queryable: queryable, pagination.RecordsPerPage);
* //Insert Take Skip
* var movies = await queryable.Paginate(pagination).ToListAsync();
* //Mapping
* var moviesDtos = _mapper.Map<List<MovieDto>>(source: movies);
* //Return
* return Ok(moviesDtos);*/
}
/// <summary>
/// Gets list object of the table NotificationsSettings.
/// </summary>
/// <param name="paginationDto">Attributes to apply the pagination.</param>
/// <param name="listFilterNotificationsSettings">List that contains the DTOs from NotificationsSettings table that filter the query.</param>
/// <returns>List object of the table NotificationsSettings.</returns>
/// <author>Mauricio Suárez.</author>
public List <NotificationsSettingsDto> GetNotificationsSettings(PaginationDto paginationDto, NotificationsSettingsDto dtoNotificationsSettings)
{
List <NotificationsSettingsDto> listFilterNotificationsSettings = new List <NotificationsSettingsDto>();
listFilterNotificationsSettings.Add(dtoNotificationsSettings);
return(this.ExecuteGetNotificationsSettings(paginationDto, listFilterNotificationsSettings));
}
public async Task <PagedList <RouteDto> > GetAllByTripIdAsync(int tripId,
string searchString,
PaginationDto paginationDto)
{
await ValidateTripExistsAsync(tripId);
var routeEntitiesQuery = _tripFlipDbContext
.Routes
.AsNoTracking()
.Where(r => r.TripId == tripId);
if (!string.IsNullOrEmpty(searchString))
{
routeEntitiesQuery = routeEntitiesQuery
.Where(routeEntity => routeEntity.Title.Contains(searchString));
}
int pageNumber = paginationDto.PageNumber ?? 1;
int pageSize = paginationDto.PageSize ?? await routeEntitiesQuery.CountAsync();
var pagedRouteEntities = routeEntitiesQuery
.ToPagedList(pageNumber, pageSize);
var pagedRouteDtos = _mapper
.Map <PagedList <RouteDto> >(pagedRouteEntities);
return(pagedRouteDtos);
}
/// <summary>
/// Gets list object of the table AssociateUsersGroup.
/// </summary>
/// <param name="paginationDto">Attributes to apply the pagination.</param>
/// <param name="listFilterAssociateUsersGroup">List that contains the DTOs from AssociateUsersGroup table that filter the query.</param>
/// <returns>List object of the table AssociateUsersGroup.</returns>
/// <author>Mauricio Suárez.</author>
public List <AssociateUsersGroupDto> GetAssociateUsersGroup(PaginationDto paginationDto, AssociateUsersGroupDto dtoAssociateUsersGroup)
{
List <AssociateUsersGroupDto> listFilterAssociateUsersGroup = new List <AssociateUsersGroupDto>();
listFilterAssociateUsersGroup.Add(dtoAssociateUsersGroup);
return(this.ExecuteGetAssociateUsersGroup(paginationDto, listFilterAssociateUsersGroup));
}
public PaginationDto <GlnSummaryDto> GetPagedGlnsBySearchTerm(int pageNumber, int pageSize = 10,
string searchTerm = "")
{
if (!string.IsNullOrWhiteSpace(searchTerm))
{
var totalCount =
_db.Glns.Count(
bc =>
bc.Assigned && bc.OwnGln.StartsWith(searchTerm) ||
bc.FriendlyDescriptionPurpose.StartsWith(searchTerm));
var totalPages = Math.Ceiling((double)totalCount / pageSize);
if (totalPages < pageNumber || searchTerm == "")
{
pageNumber = 1;
}
var glns = _db.Glns.Where(bc => bc.Assigned)
.Where(bc => bc.OwnGln.StartsWith(searchTerm) || bc.FriendlyDescriptionPurpose.Contains(searchTerm))
.OrderBy(bc => bc.FriendlyDescriptionPurpose)
.ThenBy(bc => bc.OwnGln)
.Skip((pageNumber - 1) * pageSize)
.Take(pageSize * 3)
.Select(DtoHelper.CreateGlnSummaryDto);
var paginationDto = new PaginationDto <GlnSummaryDto>(pageNumber, pageSize, totalCount, glns);
return(paginationDto);
}
else
{
var paginationDto = GetPagedGlns(1, pageSize);
return(paginationDto);
}
}
public static IEnumerable <T> Paginate <T>(this IEnumerable <T> entities, PaginationDto pagination)
{
return(entities
.OrderBy(pagination.Order + " " + pagination.SortOrder)
.Skip((pagination.Page - 1) * pagination.PageSize)
.Take(pagination.PageSize));
}
public async Task <IActionResult> GetAll(
[FromRoute] Guid tenantId,
[FromQuery] int?contentTypeCode = null,
[FromQuery] DateTime?filterDateBegin = null,
[FromQuery] DateTime?filterDateEnd = null,
[FromQuery] int?pageIndex = null,
[FromQuery] int?pageSize = null)
{
RulesFilterDto rulesFilterDto = null;
PaginationDto paginationDto = null;
if (contentTypeCode != null || filterDateBegin != null || filterDateEnd != null)
{
rulesFilterDto = new RulesFilterDto
{
ContentTypeCode = contentTypeCode,
FilterDateBegin = filterDateBegin,
FilterDateEnd = filterDateEnd
};
}
if (pageIndex != null && pageSize != null)
{
paginationDto = new PaginationDto
{
PageIndex = pageIndex.GetValueOrDefault(),
PageSize = pageSize.GetValueOrDefault()
};
}
IEnumerable <RuleDto> ruleDtos = await this.ruleService.GetAll(tenantId, rulesFilterDto, paginationDto);
return(this.Ok(ruleDtos));
}
/// <summary>
/// Gets list object of the table Application.
/// </summary>
/// <param name="paginationDto">Attributes to apply the pagination.</param>
/// <param name="listFilterApplication">List that contains the DTOs from Application table that filter the query.</param>
/// <returns>List object of the table Application.</returns>
/// <author>Mauricio Suárez.</author>
public List <ApplicationDto> GetApplication(PaginationDto paginationDto, ApplicationDto dtoApplication)
{
List <ApplicationDto> listFilterApplication = new List <ApplicationDto>();
listFilterApplication.Add(dtoApplication);
return(this.ExecuteGetApplication(paginationDto, listFilterApplication));
}
protected void SetUsers(PaginationDto <OrderDto> sources, List <User> users)
{
sources.Data.ForEach(c =>
{
c.User = users.FirstOrDefault(i => i.Id == c.UserId)?.ToDto();
});
}
protected void SetUsers(PaginationDto <Domain.Dto.Home.ContactUsDto> sources, List <User> users)
{
sources.Data.ForEach(c =>
{
c.User = users.FirstOrDefault(i => i.Id == c.UserId)?.ToDto();
});
}
public async Task <IEnumerable <T> > GetListAsync(PaginationDto pagination)
{
var query = _dbSet.AsNoTracking().OrderByDescending(c => c.Id).AsQueryable();
var result = await query.Skip(pagination.PageIndex).Take(pagination.PageSize).ToListAsync();
return(result);
}
public async Task GetAll_ReachUnexistPage_ReturnResultWithPagination()
{
// ===== Arrange =====
var dbName = Guid.NewGuid().ToString();
var context = BuildContext(dbName);
var mapper = BuildMap();
var httpContext = new Mock <IHttpContextAccessor>();
var http = new DefaultHttpContext();
httpContext.Setup(_ => _.HttpContext).Returns(http);
// Add Mockup data
await Generate_ProductGroup_Data(context, mapper, httpContext.Object);
// Prepare instance for testing
var actContext = BuildContext(dbName);
PaginationDto pagination = new PaginationDto {
Page = 5, RecordsPerPage = 2
};
string filter = null;
DataOrderDTO order = new DataOrderDTO();
// ===== Act =====
var service = new ProductGroupServices(actContext, mapper, httpContext.Object);
var result = await service.GetAll(pagination, filter, order);
// ===== Assert =====
// Result : Check on Page Doesn't exist
// Expected Exception
}
public async Task <PagedList <TaskDto> > GetAllByTaskListIdAsync(int taskListId,
string searchString,
PaginationDto paginationDto)
{
var taskListExists = await _tripFlipDbContext
.TaskLists
.AnyAsync(taskListEntity => taskListEntity.Id == taskListId);
if (!taskListExists)
{
throw new NotFoundException(ErrorConstants.TaskListNotFound);
}
var taskEntitiesQuery = _tripFlipDbContext
.Tasks
.AsNoTracking()
.Where(taskEntity => taskEntity.TaskListId == taskListId);
if (!string.IsNullOrEmpty(searchString))
{
taskEntitiesQuery =
taskEntitiesQuery
.Where(taskEntity => taskEntity.Description
.Contains(searchString));
}
var pageNumber = paginationDto.PageNumber ?? 1;
var pageSize = paginationDto.PageSize ?? await taskEntitiesQuery.CountAsync();
var pagedTaskEntities = taskEntitiesQuery.ToPagedList(pageNumber, pageSize);
var pagedTaskDtos = _mapper.Map <PagedList <TaskDto> >(pagedTaskEntities);
return(pagedTaskDtos);
}
public async Task <PagedList <ItemDto> > GetAllByItemListIdAsync(int itemListId,
string searchString,
PaginationDto paginationDto)
{
var itemListExists = await _tripFlipDbContext.ItemLists
.AnyAsync(l => l.Id == itemListId);
if (!itemListExists)
{
throw new NotFoundException(ErrorConstants.ItemListNotFound);
}
var itemEntitiesQuery = _tripFlipDbContext.Items
.Where(i => i.ItemListId == itemListId)
.AsNoTracking();
if (!string.IsNullOrEmpty(searchString))
{
itemEntitiesQuery = itemEntitiesQuery
.Where(i => i.Title.Contains(searchString) || i.Comment.Contains(searchString));
}
var pageNumber = paginationDto.PageNumber ?? 1;
var pageSize = paginationDto.PageSize ?? await itemEntitiesQuery.CountAsync();
var pagedItemEntities = itemEntitiesQuery.ToPagedList(pageNumber, pageSize);
var pagedItemDtos = _mapper.Map <PagedList <ItemDto> >(pagedItemEntities);
return(pagedItemDtos);
}
/// <summary>
/// Gets list object of the table CompanyApplication.
/// </summary>
/// <param name="paginationDto">Attributes to apply the pagination.</param>
/// <param name="listFilterCompanyApplication">List that contains the DTOs from CompanyApplication table that filter the query.</param>
/// <returns>List object of the table CompanyApplication.</returns>
/// <author>Mauricio Suarez.</author>
public List <CompanyApplicationDto> GetCompanyApplication(PaginationDto paginationDto, CompanyApplicationDto dtoCompanyApplication)
{
List <CompanyApplicationDto> listFilterCompanyApplication = new List <CompanyApplicationDto>();
listFilterCompanyApplication.Add(dtoCompanyApplication);
return(this.ExecuteGetCompanyApplication(paginationDto, listFilterCompanyApplication));
}
/// <summary>
/// Gets list object of the table CompanyApplication.
/// </summary>
/// <param name="paginationDto">Attributes to apply the pagination.</param>
/// <param name="listCompanyApplicationDto">List that contains the DTOs from CompanyApplication table that filter the query.</param>
/// <returns>List object of the table CompanyApplication.</returns>
/// <author>Mauricio Suarez.</author>
private List <CompanyApplicationDto> ExecutePaginated(PaginationDto paginationDto, List <CompanyApplicationDto> listCompanyApplicationDto)
{
using (SecurityManagmentEntities context = new SecurityManagmentEntities())
{
if (string.IsNullOrEmpty(paginationDto.SortExpression))
{
paginationDto.SortExpression = "IdCompanyApplication";
paginationDto.SortDirection = "ASC";
}
if (paginationDto.PageSize == 0 && paginationDto.CurrentPage == 0)
{
paginationDto.PageSize = int.MaxValue;
}
var predicate = ConditionalQuery.GeneratePredicateQuery <CompanyApplication, CompanyApplicationDto>(listCompanyApplicationDto);
return(context.CompanyApplication.AsExpandable()
.Include(ConditionalQuery.GenerateIncludes(listCompanyApplicationDto))
.Where(predicate).AsParallel()
.OrderBy(paginationDto.SortExpression + " " + paginationDto.SortDirection)
.Skip(paginationDto.CurrentPage * paginationDto.PageSize)
.Take(paginationDto.PageSize)
.Select(Mapper.Map <CompanyApplication, CompanyApplicationDto>).ToList());
}
}
public async Task <IActionResult> GetContactListByMail(string mail, [FromBody] PaginationDto pagination)
{
if (ModelState.IsValid)
{
return(buildResponse(await _service.GetContactsByMail(mail, pagination)));
}
return(null);
}
public async Task <ActionResult <List <UserDto> > > Get([FromQuery] PaginationDto paginationDTO)
{
var queryable = _context.Users.AsQueryable();
queryable = queryable.OrderBy(x => x.Email);
return(await Get <IdentityUser, UserDto>(paginationDTO));
}
public PaginatedResult <Entities.WashingTime.WashingTime> Get(
[FromQuery] PaginationDto pagination,
[FromQuery(Name = "")] WashingTimeFilter filter,
[FromQuery] string include
)
{
return(_repository.Query.ApplyFilters(filter).Paginate(pagination.Page, pagination.PageSize));
}
public async Task <ActionResult <List <CategoryDto> > > GetAllCategory([FromQuery] PaginationDto pagination)
{
var categories = await repository.GetAll(HttpContext, pagination);
var categoriesDto = mapper.Map <List <CategoryDto> >(categories);
return(categoriesDto);
}
public async Task <ActionResult <List <ProducerDto> > > GetAllProducers([FromQuery] PaginationDto pagination)
{
var producer = await repository.GetAll(HttpContext, pagination, x => x.Products);
var producerDto = mapper.Map <List <ProducerDto> >(producer);
return(producerDto);
}
public async Task <ActionResult <List <RatingDto> > > GetAllRatings([FromQuery] PaginationDto pagination)
{
var ratings = await repository.GetAll(HttpContext, pagination);
var ratingsDto = mapper.Map <List <RatingDto> >(ratings);
return(ratingsDto);
}
public async Task <ActionResult <List <ProductDto> > > GetAllProducts([FromQuery] PaginationDto pagination)
{
var products = await repository.GetAll(HttpContext, pagination, x => x.Category, y => y.Producer, z => z.Ratings);
var productsDto = mapper.Map <List <ProductDto> >(products);
return(productsDto);
}
private async Task GetPagination(GetArticlesQuery request)
{
var pagesCount = await articleRepository.GetPublishedPagesCount(request.PageSize, request.CategoryId);
var currentPage = pagesCount < request.Page ? pagesCount : request.Page;
pagination = new PaginationDto(pagesCount, currentPage, request.PageSize);
}
