public async Task <ServiceResponseWithPagination <List <ProductGroupDTO_ToReturn> > > GetProductGroupFilter(ProductGroupDTO_Filter input)
{
var queryable = _context.ProductGroups.AsQueryable();
//Filter
if (!string.IsNullOrWhiteSpace(input.Name))
{
queryable = queryable.Where(x => x.Name.Contains(input.Name));
}
//Ordering
if (!string.IsNullOrWhiteSpace(input.OrderingField))
{
try
{
queryable = queryable.OrderBy($"{input.OrderingField} {(input.AscendingOrder ? "asc" : "desc")}");
}
catch (System.Exception ex)
{
_logger.LogError(ex.Message);
return(ResponseResultWithPagination.Failure <List <ProductGroupDTO_ToReturn> >(ex.Message));
}
}
var paginationResult = await _httpContext.HttpContext.InsertPaginationParametersInResponse(queryable, input.RecordsPerPage, input.Page);
var data = await queryable.Paginate(input).ToListAsync();
var dto = _mapper.Map <List <ProductGroupDTO_ToReturn> >(data);
return(ResponseResultWithPagination.Success(dto, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <BookDTO_ToReturn> > > SearchPagination(BookDTO_Filter filter)
{
var book = _dbContext.Books.Include(x => x.CategoryBooks).AsQueryable();
if (!string.IsNullOrWhiteSpace(filter.Name))
{
book = book.Where(x => x.Name.Contains(filter.Name));
}
book = book.Where(x => x.CategoryBooks.CodeType == filter.CategoryCode);
book = book.Where(x => x.BorrowPrice >= filter.MinPrice);
// 2. Order => Order by
if (!string.IsNullOrWhiteSpace(filter.OrderingField))
{
try
{
book = book.OrderBy($"{filter.OrderingField} {(filter.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
return(ResponseResultWithPagination.Failure <List <BookDTO_ToReturn> >($"Could not order by field: {filter.OrderingField}"));
}
}
var paginationResult = await _httpContext.HttpContext.InsertPaginationParametersInResponse(book, filter.RecordsPerPage, filter.Page);
// var custom = await cus.Paginate(filter).ToListAsync();
var result = _mapper.Map <List <BookDTO_ToReturn> >(await book.Paginate(filter).ToListAsync());
return(ResponseResultWithPagination.Success(result, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <CustomerDTO_ToRetun> > > SearchPagination(CustomerDTO_Filter filter)
{
var cus = _dbContext.Customers.AsQueryable();
if (!string.IsNullOrWhiteSpace(filter.Name))
{
cus = cus.Where(x => x.Name.Contains(filter.Name));
}
cus = cus.Where(x => x.Email.Contains(filter.Email));
// 2. Order => Order by
if (!string.IsNullOrWhiteSpace(filter.OrderingField))
{
try
{
cus = cus.OrderBy($"{filter.OrderingField} {(filter.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
return(ResponseResultWithPagination.Failure <List <CustomerDTO_ToRetun> >($"Could not order by field: {filter.OrderingField}"));
}
}
var paginationResult = await _httpContext.HttpContext.InsertPaginationParametersInResponse(cus, filter.RecordsPerPage, filter.Page);
// var custom = await cus.Paginate(filter).ToListAsync();
var result = _mapper.Map <List <CustomerDTO_ToRetun> >(await cus.Paginate(filter).ToListAsync());
return(ResponseResultWithPagination.Success(result, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <CategoryBookDTO_ToReturn> > > SearchPaginate(CategoryBookDTO_Filter filter)
{
//สามารถคิวรี่ได้ ปั้นตัวคิวรี่โดยยังไม่แตะดาต้าเบส excute 2 รอบ
var categoryBook = _dbContext.CategoryBooks.AsQueryable();
if (!string.IsNullOrWhiteSpace(filter.Name))
{
categoryBook = categoryBook.Where(x => (x.CodeType).Contains(filter.Name));
}
// 2. Order => Order by
if (!string.IsNullOrWhiteSpace(filter.OrderingField))
{
try
{
categoryBook = categoryBook.OrderBy($"{filter.OrderingField} {(filter.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
return(ResponseResultWithPagination.Failure <List <CategoryBookDTO_ToReturn> >($"Could not order by field: {filter.OrderingField}"));
}
}
// 3. Add Paginate => Page,total,Perpage
var paginationResult = await _httpContext.HttpContext.InsertPaginationParametersInResponse(categoryBook, filter.RecordsPerPage, filter.Page);
// 4. Execute Query
var category = await categoryBook.Paginate(filter).ToListAsync();
// 5. Return result
var result = _mapper.Map <List <CategoryBookDTO_ToReturn> >(category);
return(ResponseResultWithPagination.Success(result, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <OrderDto_ToReturn> > > SearchPagination(OrderDto_Filter filter)
{
var order = _dbContext.Orders.Include(x => x.OrderItems).ThenInclude(x => x.Products).AsQueryable();
order = order.Where(x => x.IsActive == filter.IsActive);
// 2. Order => Order by
if (!string.IsNullOrWhiteSpace(filter.OrderingField))
{
try
{
order = order.OrderBy($"{filter.OrderingField} {(filter.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
return(ResponseResultWithPagination.Failure <List <OrderDto_ToReturn> >($"Could not order by field: {filter.OrderingField}"));
}
}
var paginationResult = await _httpContext.HttpContext.InsertPaginationParametersInResponse(order, filter.RecordsPerPage, filter.Page);
// var custom = await cus.Paginate(filter).ToListAsync();
var result = _mapper.Map <List <OrderDto_ToReturn> >(await order.Paginate(filter).ToListAsync());
return(ResponseResultWithPagination.Success(result, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <ProductGroupDto_ToReturn> > > SearchPagination(ProductGroupDto_Filter filter)
{
var productGroup = _dbContext.ProductGroups.AsQueryable();
if (!string.IsNullOrWhiteSpace(filter.Name))
{
productGroup = productGroup.Where(x => x.Name.ToLower().Contains(filter.Name.ToLower()));
}
productGroup = productGroup.Where(x => x.IsActive == filter.IsActive);
if (!string.IsNullOrWhiteSpace(filter.OrderingField))
{
try
{
productGroup = productGroup.OrderBy($"{filter.OrderingField} {(filter.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
return(ResponseResultWithPagination.Failure <List <ProductGroupDto_ToReturn> >($"Could not order by field: {filter.OrderingField}"));
}
}
var paginationResult = await _httpContext.HttpContext.InsertPaginationParametersInResponse(productGroup, filter.RecordsPerPage, filter.Page);
var result = _mapper.Map <List <ProductGroupDto_ToReturn> >(await productGroup.Paginate(filter).ToListAsync());
return(ResponseResultWithPagination.Success(result, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <mOrder> > > GetOrderWithFilterByDate(GetOrderDateFilterDTO orderFilter)
{
var Queryable = _dbContext.Orders.AsQueryable();
if (orderFilter.DateFrom != null && orderFilter.DateTo != null)
{
//Queryable = Queryable.Where(x => x.DateOrder >= orderFilter.DateFrom.Value && x.DateOrder <= orderFilter.DateTo.Value.AddDays(1));
Queryable = Queryable.Where(x => x.DateOrder >= orderFilter.DateFrom.Value.Date && x.DateOrder <= orderFilter.DateTo.Value.AddDays(1).Date);
}
if (!string.IsNullOrWhiteSpace(orderFilter.OrderingField))
{
try
{
Queryable = Queryable.OrderBy($"{orderFilter.OrderingField} {(orderFilter.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
return(ResponseResultWithPagination.Failure <List <Models.Order.Order> >($"Could not order by field: {orderFilter.OrderingField}"));
}
;
}
var paginationResult = await _httpcontext.HttpContext.InsertPaginationParametersInResponse(Queryable, orderFilter.RecordsPerPage, orderFilter.Page);
var dto = await Queryable.Paginate(orderFilter).ToListAsync();
return(ResponseResultWithPagination.Success(dto, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <GetProductDto> > > GetProductFilter(ProductFilterDto filter)
{
var queryable = _dBContext.Products.Include(x => x.ProductGroup).AsNoTracking().AsQueryable();
//Filter
if (!string.IsNullOrWhiteSpace(filter.Name))
{
queryable = queryable.Where(x => x.Name.Contains(filter.Name.Trim()));
}
//Ordering
if (!string.IsNullOrWhiteSpace(filter.OrderingField))
{
try
{
queryable = queryable.OrderBy($"{filter.OrderingField} {(filter.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
return(ResponseResultWithPagination.Failure <List <GetProductDto> >($"Could not order by field: {filter.OrderingField}"));
}
}
var paginationResult = await _httpContext.HttpContext
.InsertPaginationParametersInResponse(queryable, filter.RecordsPerPage, filter.Page);
var dto = await queryable.Paginate(filter).AsNoTracking().ToListAsync();
var prodDto = _mapper.Map <List <GetProductDto> >(dto);
return(ResponseResultWithPagination.Success(prodDto, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <Bulk> > > GetBulkFilter(BulkFilterDto filter)
{
var queryable = _dBContext.Bulk.AsQueryable();
//Filter
if (!string.IsNullOrWhiteSpace(filter.BulkName))
{
queryable = queryable.Where(x => x.BulkName.Contains(filter.BulkName));
}
if (!string.IsNullOrWhiteSpace(filter.BulkCode))
{
queryable = queryable.Where(x => x.BulkCode.Contains(filter.BulkCode));
}
//Ordering
if (!string.IsNullOrWhiteSpace(filter.OrderingField))
{
try
{
queryable = queryable.OrderBy($"{filter.OrderingField} {(filter.AscendingOrder ? "asc" : "desc")}");
}
catch (System.Exception)
{
return(ResponseResultWithPagination.Failure <List <Bulk> >(string.Format("Could not order by field : {0}", filter.OrderingField)));
}
}
var paginationResult = await _httpContext.HttpContext.InsertPaginationParametersInResponse(queryable, filter.RecordsPerPage, filter.Page);
var dto = await queryable.Paginate(filter).ToListAsync();
return(ResponseResultWithPagination.Success(dto, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <StockCardDto> > > StockCardFilter(StockCardFilterDto filter)
{
var queryable = _dbContext.StockCards.Include(x => x.User).Include(x => x.Product).ThenInclude(x => x.ProductGroup).AsQueryable();
//var queryable = _dbContext.StockCards.AsQueryable();
//Filter
if (!string.IsNullOrWhiteSpace(filter.Name) && filter.Name != "")
{
queryable = queryable.Where(x => x.Product.Name.Contains(filter.Name));
}
if (filter.IsActive != null)
{
queryable = queryable.Where(x => x.IsActive.Equals(filter.IsActive));
}
//Ordering
if (!string.IsNullOrWhiteSpace(filter.OrderingField))
{
try
{
queryable = queryable.OrderBy($"{filter.OrderingField} {(filter.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
return(ResponseResultWithPagination.Failure <List <StockCardDto> >($"Could not order by field: {filter.OrderingField}"));
}
}
var paginationResult = await _httpContext.HttpContext
.InsertPaginationParametersInResponse(queryable, filter.RecordsPerPage, filter.Page);
var StockCard = await queryable.Paginate(filter).ToListAsync();
var dto = _mapper.Map <List <StockCardDto> >(StockCard);
return(ResponseResultWithPagination.Success(dto, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <ProductGroupDTO> > > GetAll(PaginationDto pagination = null, string productGroupfilter = null, DataOrderDTO ordering = null)
{
// Quering data
var query = _dbContext.ProductGroup.AsQueryable();
// Filtering data
if (!(String.IsNullOrEmpty(productGroupfilter)))
{
query = query.Where(x => x.Name.Contains(productGroupfilter));
}
// Ordering
if (!(ordering is null))
{
var columns = new List <string> {
"Id", "Name", "CreatedBy", "CreatedDate", "Status"
};
if (columns.Exists(x => x == ordering.OrderBy))
{
if (ordering.OrderBy == "CreatedBy")
{
ordering.OrderBy = "CreatedByUser.Username";
}
var property = $"{ordering.OrderBy}";
if (!String.IsNullOrEmpty(ordering.Sort) && ordering.Sort.ToLower() == "desc")
{
query = ApplyOrder(query, property, "OrderByDescending");
}
else
{
query = ApplyOrder(query, property, "OrderBy");
}
}
}
// Pagination
var paginationResult = await _httpContext.HttpContext.InsertPaginationParametersInResponse(query, pagination.RecordsPerPage, pagination.Page);
// Generate result
var result = await query.Paginate(pagination).Include(_ => _.CreatedByUser).ToListAsync();
//await query.Paginate(pagination).Include(_=>_.CreatedByUser).DefaultIfEmpty().ToListAsync();
// Return error if count is 0
if (result.Count == 0)
{
throw new InvalidOperationException("Product Group is not Exist");
}
// Mapping
var dto = _mapper.Map <List <ProductGroupDTO> >(result);
// Return Results
return(ResponseResultWithPagination.Success <List <ProductGroupDTO> >(dto, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <Bulk> > > GetBulkWithPagination(PaginationDto pagination)
{
var queryable = _dBContext.Bulk.AsQueryable();
var paginationResult = await _httpContext.HttpContext.InsertPaginationParametersInResponse(queryable, pagination.RecordsPerPage, pagination.Page);
var dto = await queryable.Paginate(pagination).ToListAsync();
return(ResponseResultWithPagination.Success(dto, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <ProductDTO> > > GetAll(PaginationDto pagination = null, ProductFilterDTO productFilter = null, DataOrderDTO ordering = null)
{
// Quering data
var query = _dbContext.Product.AsQueryable();
// Filtering data
query = Filter(query, productFilter);
// Ordering
if (!(ordering is null))
{
var columns = new List <string> {
"Id", "GroupId", "Name", "Price", "CreatedBy", "Status"
};
if (columns.Exists(x => x == ordering.OrderBy))
{
if (ordering.OrderBy == "CreatedBy")
{
ordering.OrderBy = "CreatedByUser.Username";
}
var property = $"{ordering.OrderBy}";
if (!String.IsNullOrEmpty(ordering.Sort) && ordering.Sort.ToLower() == "desc")
{
query = ApplyOrder(query, property, "OrderByDescending");
}
else
{
query = ApplyOrder(query, property, "OrderBy");
}
}
}
// Pagination
var paginationResult = await _httpContext.HttpContext.InsertPaginationParametersInResponse(query, pagination.RecordsPerPage, pagination.Page);
// Generate result
var result = await query.Paginate(pagination).Include(entity => entity.CreatedByUser.Products).Include(entity => entity.Group).ToListAsync();
// Return error if count is 0
if (result.Count == 0)
{
return(ResponseResultWithPagination.Failure <List <ProductDTO> >("Product is not Exist", ResponseType.NoContent));
}
// Mapping
var dto = _mapper.Map <List <ProductDTO> >(result);
// Return Results
return(ResponseResultWithPagination.Success <List <ProductDTO> >(dto, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <ProductStockDTO> > > GetStockHistory(int productId, PaginationDto pagination = null)
{
string responseMessage;
// Check product is exist
if (productId <= 0)
{
throw new ArgumentOutOfRangeException("productId", productId, "Product ID must greater than 0");
}
var product = await _dbContext.Product
.Where(_ => _.Id == productId)
.FirstOrDefaultAsync();
if (product is null)
{
throw new InvalidOperationException("Product is not Exist");
}
var stockHistory = _dbContext.Stock
.Where(_ => _.ProductId == productId)
.OrderByDescending(_ => _.Id)
.AsQueryable();
var paginationResult = await _httpContext.HttpContext
.InsertPaginationParametersInResponse(
stockHistory,
pagination.RecordsPerPage,
pagination.Page
);
var result = await stockHistory.Paginate(pagination)
.Include(_ => _.CreatedByUser)
.Include(_ => _.Product)
.Include(_ => _.Product.Group)
.ToListAsync();
if (result.Count == 0)
{
responseMessage = $"Product ({product.Name}) have no recent stock records";
}
else
{
responseMessage = $"Product ({product.Name}) requested record successfully";
}
var dto = _mapper.Map <List <ProductStockDTO> >(result);
return(ResponseResultWithPagination.Success <List <ProductStockDTO> >(dto, paginationResult, responseMessage));
}
public async Task <IActionResult> GetAll([FromQuery] PaginationDto pagination, [FromQuery] OrderFilterDTO filter, [FromQuery] DataOrderDTO order)
{
try
{
var result = await _service.GetAll(pagination, filter, order);
return(Ok(result));
}
catch (Exception ex)
{
return(Ok(ResponseResultWithPagination.Failure <OrderDTO>(ex.Message)));
}
}
public async Task <IActionResult> GetAll([FromQuery] PaginationDto pagination, [FromQuery] string filter = null, [FromQuery] DataOrderDTO ordering = null)
{
try
{
var paginationResult = await _ProductGroupService.GetAll(pagination, filter, ordering);
return(Ok(paginationResult));
}
catch (Exception ex)
{
return(Ok(ResponseResultWithPagination.Failure <List <ProductGroupDTO> >(ex.Message)));
}
}
public async Task <ServiceResponseWithPagination <List <MovieDto> > > GetAllMoviesPagination(PaginationDto pagination)
{
var queryable = _context.Movies.AsQueryable();
var paginationResult = await _httpContext.HttpContext
.InsertPaginationParametersInResponse(
queryable
, pagination.RecordsPerPage
, pagination.Page);
var movies = await queryable.Paginate(pagination).ToListAsync();
List <MovieDto> movieDTOs = _mapper.Map <List <MovieDto> >(movies);
return(ResponseResultWithPagination.Success(movieDTOs, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <mProduct> > > GetProductWithFilter(GetProductFilterDto ProductFilter)
{
var Queryable = _dbContext.Products
.Include(x => x.ProductGroup)
.AsQueryable();
if (!string.IsNullOrWhiteSpace(ProductFilter.Name))
{
Queryable = Queryable.Where(x => x.Name.Contains(ProductFilter.Name));
}
if (ProductFilter.Price != null)
{
Queryable = Queryable.Where(x => x.Price == ProductFilter.Price);
}
if (ProductFilter.StockCount != null)
{
Queryable = Queryable.Where(x => x.StockCount == ProductFilter.StockCount);
}
if (ProductFilter.ProductGroupId != null)
{
Queryable = Queryable.Where(x => x.ProductGroupId == ProductFilter.ProductGroupId);
}
if (!string.IsNullOrWhiteSpace(ProductFilter.OrderingField))
{
try
{
Queryable = Queryable.OrderBy($"{ProductFilter.OrderingField} {(ProductFilter.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
return(ResponseResultWithPagination.Failure <List <Models.Product.Product> >($"Could not order by field: {ProductFilter.OrderingField}"));
}
;
}
var paginationResult = await _httpcontext.HttpContext.InsertPaginationParametersInResponse(Queryable, ProductFilter.RecordsPerPage, ProductFilter.Page);
var dto = await Queryable.Paginate(ProductFilter).ToListAsync();
return(ResponseResultWithPagination.Success(dto, paginationResult));
}
public async Task <IActionResult> GetStockHistory(int id, [FromQuery] PaginationDto pagination)
{
string errorMessage;
try
{
var result = await _services.GetStockHistory(id, pagination);
return(Ok(result));
}
catch (Exception ex)
{
errorMessage = ex.Message;
}
return(Ok(ResponseResultWithPagination.Failure <List <ProductStockDTO> >(errorMessage)));
}
public async Task <ServiceResponseWithPagination <List <GetVoiceRecordDetail> > > GetVoiceRecordDetailJson(FilterVoiceRecordDetail filter)
{
var queryable = _dBContext.VoiceRecordDetails.AsNoTracking().AsQueryable();
//************************************Start Filter*************************************//
//Filter AgentId
if (filter.ExtensionNo != null)//null is for get all AgentId
{
queryable = queryable.Where(x => x.ExtensionNo == filter.ExtensionNo);
}
//Filter CallType
if (filter.CallingType != null) //null is for get all type
{
queryable = queryable.Where(x => x.CallTypeId == filter.CallingType);
}
//Filter duration of date
if (filter.EndDate != default(DateTime))
{
queryable = queryable.Where(x => x.CreatedDate >= filter.StartDate && x.CreatedDate <= filter.EndDate);
}
//************************************End Filter*************************************//
//Ordering
if (!string.IsNullOrWhiteSpace(filter.OrderingField))
{
try
{
queryable = queryable.OrderBy($"{filter.OrderingField} {(filter.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
return(ResponseResultWithPagination.Failure <List <GetVoiceRecordDetail> >($"Could not order by field: {filter.OrderingField}"));
}
}
var paginationResult = await _httpContext.HttpContext
.InsertPaginationParametersInResponse(queryable, filter.RecordsPerPage, filter.Page);
var dto = await queryable.Paginate(filter).AsNoTracking().ToListAsync();
var VoiceDto = _mapper.Map <List <GetVoiceRecordDetail> >(dto);
return(ResponseResultWithPagination.Success(VoiceDto, paginationResult));
}
public async Task <ServiceResponse <List <OrderDTO_ToReturn> > > SearchOrderPaginate(OrderDTO_Filter filter)
{
var queryable = _dbContext.Orders.AsQueryable();
//filter
if (!String.IsNullOrWhiteSpace(filter.PaymentType))
{
queryable = queryable.Where(x => (x.PaymentType).Contains(filter.PaymentType));
}
if (filter.MinPrice != 0)
{
queryable = queryable.Where(x => x.TotalPrice >= filter.MinPrice);
}
//Order By
if (!string.IsNullOrWhiteSpace(filter.OrderingField))
{
try
{
queryable = queryable.OrderBy($"{filter.OrderingField} {(filter.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
return(ResponseResultWithPagination.Failure <List <OrderDTO_ToReturn> >($"Could not order by field: {filter.OrderingField}"));
}
}
//Add Paginate
var paginationResult = await _httpContext.HttpContext.InsertPaginationParametersInResponse(queryable, filter.RecordsPerPage, filter.Page);
//Excute query
var order = await queryable.Paginate(filter).ToListAsync();
var result = _mapper.Map <List <OrderDTO_ToReturn> >(order);
return(ResponseResultWithPagination.Success(result, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <BookDTO_ToReturn> > > SearchPaginate(BookDTO_Filter filter)
{
// 1. Filter => Search
var queryable = _db.Books.AsQueryable();
if (!string.IsNullOrWhiteSpace(filter.Name))
{
queryable = queryable.Where(x => (x.Name).Contains(filter.Name));
}
queryable = queryable.Where(x => x.Price >= filter.MinPrice);
queryable = queryable.Where(x => x.Price <= filter.MaxPrice);
// 2. Order => Order by
if (!string.IsNullOrWhiteSpace(filter.OrderingField))
{
try
{
queryable = queryable.OrderBy($"{filter.OrderingField} {(filter.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
return(ResponseResultWithPagination.Failure <List <BookDTO_ToReturn> >($"Could not order by field: {filter.OrderingField}"));
}
}
// 3. Add Paginate => Page,total,Perpage
var paginationResult = await _httpContext.HttpContext.InsertPaginationParametersInResponse(queryable, filter.RecordsPerPage, filter.Page);
// 4. Execute Query
var books = await queryable.Paginate(filter).ToListAsync();
// 5. Return result
var result = _mapper.Map <List <BookDTO_ToReturn> >(books);
return(ResponseResultWithPagination.Success(result, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <MovieDto> > > Filter(MovieDtoFilter filter)
{
var query = _context.Movies.AsQueryable();
//Filter
if (!string.IsNullOrWhiteSpace(filter.Title))
{
query = query.Where(x => x.Title.Contains(filter.Title));
}
if (filter.UpcomingReleases)
{
query = query.Where(x => x.InTheaters);
}
if (filter.UpcomingReleases)
{
var today = new DateTime(2020, 01, 01);
query = query.Where(x => x.ReleaseDate > today);
}
if (filter.GenreId != 0)
{
query = query.Where(x => x.MoviesGenres.Select(y => y.GenreId)
.Contains(filter.GenreId));
}
//Ordering
if (!string.IsNullOrWhiteSpace(filter.OrderingField))
{
try
{
//nuget system.linq.dynamic.core
query = query.OrderBy($"{filter.OrderingField} {(filter.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
return(ResponseResultWithPagination.Failure <List <MovieDto> >("Could not order by field: " + filter.OrderingField));
}
//if (filter.OrderingField == "title")
//{
// if (filter.AscendingOrder)
// {
// query = query.OrderBy(x => x.Title);
// }
// else
// {
// query = query.OrderByDescending(x => x.Title);
// }
//}
}
var paginationResult = await _httpContext.HttpContext
.InsertPaginationParametersInResponse(
query
, filter.RecordsPerPage
, filter.Page);
var movies = await query.Paginate(filter).ToListAsync();
List <MovieDto> movieDTOs = _mapper.Map <List <MovieDto> >(movies);
return(ResponseResultWithPagination.Success(movieDTOs, paginationResult));
}
public async Task <ServiceResponseWithPagination <List <mOrder> > > GetOrderWithFilter(GetOrderFilterDto orderFilter)
{
var Queryable = _dbContext.Orders
.AsQueryable();
if (orderFilter.DateOrder != null)
{
Queryable = Queryable.Where(x => x.DateOrder.Date == orderFilter.DateOrder.Value);
}
if (orderFilter.ItemCount > 0)
{
Queryable = Queryable.Where(x => x.ItemCount == orderFilter.ItemCount);
}
if (orderFilter.Total > 0)
{
Queryable = Queryable.Where(x => x.Total == orderFilter.Total);
}
if (orderFilter.Discount > 0)
{
Queryable = Queryable.Where(x => x.Discount == orderFilter.Discount);
}
if (orderFilter.Net > 0)
{
Queryable = Queryable.Where(x => x.Net == orderFilter.Net);
}
if (!string.IsNullOrWhiteSpace(orderFilter.OrderNumber))
{
Queryable = Queryable.Where(x => x.OrderNumber.Contains(orderFilter.OrderNumber));
}
if (orderFilter.Status != null)
{
Queryable = Queryable.Where(x => x.Status == orderFilter.Status);
}
if (!string.IsNullOrWhiteSpace(orderFilter.OrderingField))
{
try
{
Queryable = Queryable.OrderBy($"{orderFilter.OrderingField} {(orderFilter.AscendingOrder ? "ascending" : "descending")}");
}
catch
{
return(ResponseResultWithPagination.Failure <List <Models.Order.Order> >($"Could not order by field: {orderFilter.OrderingField}"));
}
;
}
var paginationResult = await _httpcontext.HttpContext.InsertPaginationParametersInResponse(Queryable, orderFilter.RecordsPerPage, orderFilter.Page);
var dto = await Queryable.Paginate(orderFilter).ToListAsync();
return(ResponseResultWithPagination.Success(dto, paginationResult));
}
