public async Task <Response <List <OrderResource> > > GetOrders([FromQuery] GetOrdersQuery query)
{
var pagedOrder = await mediator.Send(query);
Response.AddPaginationToHeader(new Pagination(pagedOrder.Item.PageNumber, pagedOrder.Item.PageSize, pagedOrder.Item.TotalPages, pagedOrder.Item.TotalCount));
return(book.Application.common.Response.Ok <List <OrderResource> >(pagedOrder.Item.ToList()));
}
public async Task <ActionResult <IEnumerable <OrdersDto> > > GetOrdersByUserName(string userName)
{
var query = new GetOrdersQuery(userName);
var orders = await _mediator.Send(query);
return(Ok(orders));
}
public async Task <List <OrderItinerary> > Handle(GetOrdersQuery request, CancellationToken cancellationToken)
{
List <OrderItinerary> orderItineraries = new List <OrderItinerary>();
try
{
// order: order-001, flightNumber: 1, departure: <departure_city>, arrival: <arrival_city>, day: x
orderItineraries =
(
from fs in _dataContext.FlightSchedules
from o in fs.Orders
select new OrderItinerary
{
Destination = fs.Destination,
FlightDay = fs.FlightDay,
FlightNumber = fs.FlightNumber,
OrderLabel = o.OrderLabel,
Origin = fs.Origin
}
)
.OrderBy(o => o.OrderLabel)
.ToList();
}
catch (Exception ex)
{
Console.WriteLine("Uh-oh! Error: {0}", ex.Message);
}
return(orderItineraries);
}
public async Task <ActionResult <IEnumerable <Order> > > List([FromBody] GetOrdersQuery query)
{
var user = await GetUser();
query.UserId = user.Id;
query.IncludeItem = true;
return(Ok(await Mediator.Send(query)));
}
public async Task <IResult <IEnumerable <OrderDto> > > Handle(GetOrdersQuery request, CancellationToken cancellationToken)
{
var result = await _unitOfWork.GetRepository <Order>().Get();
var orders = result.Value.Where(x => x.State.Equals(request.State)).ToList();
return(Result.Success().For(_mapper.Map <IEnumerable <OrderDto> >(orders)));
}
public async Task <IEnumerable <OrderDTO> > Handle(GetOrdersQuery request, CancellationToken cancellationToken)
{
var orders = await _orderRepository.GetAwaitingOrFinishedOrders();
var result = orders.Select(x => new OrderDTO(x));
return(result);
}
public async Task <Result <IEnumerable <OrderForListDto> > > Handle(GetOrdersQuery request, CancellationToken cancellationToken)
{
var orders = await _repo.GetOrders();
var orderForList = _mapper.Map <IEnumerable <OrderForListDto> >(orders);
return(Result <IEnumerable <OrderForListDto> > .Success(orderForList));
}
public async Task <IActionResult> GetAsync()
{
var query = new GetOrdersQuery();
var response = await _mediator.Send(query);
return(JsonResult(response));
}
public async Task <ICollection <OrderResponseModel> > Handle(GetOrdersQuery request,
CancellationToken cancellationToken)
{
var order = await _orderRepository.GetAsync();
var response = order.Adapt <ICollection <OrderResponseModel> >();
return(response);
}
public Task <IQueryable <Order> > Handle(GetOrdersQuery request, CancellationToken cancellationToken)
{
var selectedPropertiesList = request.GraphQLContext.GetSelectedPropertiesListAsString();
var results = _context
.Orders
.Select <Order>($"new({selectedPropertiesList})");
return(Task.FromResult(results));
}
public async Task <IReadOnlyCollection <OrderReadModel> > ExecuteQueryAsync(GetOrdersQuery query, CancellationToken cancellationToken)
{
var readModels = await _msSqlConnection.QueryAsync <OrderReadModel>(
Label.Named("Orders"),
cancellationToken,
"SELECT * FROM [Orders]")
.ConfigureAwait(false);
return(readModels.ToList());
}
public override async Task <List <OrderDetailsViewModel> > ExecuteQuery(GetOrdersQuery query,
CancellationToken cancellationToken)
{
List <OrderDetailsViewModel> viewModelList = new List <OrderDetailsViewModel>();
var customerId = new CustomerId(query.CustomerId);
var customer = await _unitOfWork.Customers
.GetById(customerId, cancellationToken);
if (customer == null)
{
throw new ApplicationDataException("Custumer not found.");
}
var isOrderPlacedByCustomer = new IsOrderPlacedByCustomer(customer.Id);
var customerOrders = await _unitOfWork.Orders.Find(isOrderPlacedByCustomer);
foreach (var order in customerOrders)
{
var productIds = order.OrderLines.
Select(p => p.ProductId).ToList();
var products = await _unitOfWork.Products
.GetByIds(productIds, cancellationToken);
OrderDetailsViewModel viewModel = new OrderDetailsViewModel();
viewModel.OrderId = order.Id.Value;
viewModel.CreatedAt = order.CreatedAt.ToString();
viewModel.Status = OrderStatusPrettier.Prettify(order.Status);
foreach (var orderLine in order.OrderLines)
{
var product = products.Single(
(System.Func <Domain.Products.Product, bool>)
(p => p.Id == orderLine.ProductId));
var currency = Currency
.FromCode(orderLine.ProductExchangePrice.CurrencyCode);
viewModel.OrderLines.Add(new OrderLinesDetailsViewModel
{
ProductId = orderLine.ProductId.Value,
ProductQuantity = orderLine.Quantity,
ProductPrice = orderLine.ProductExchangePrice.Value,
ProductName = product.Name,
CurrencySymbol = currency.Symbol,
});
}
viewModel.CalculateTotalOrderPrice();
viewModelList.Add(viewModel);
}
return(viewModelList);
}
public async Task <ActionResult <PagedList <OrderDto> > > GetAllOrdersAsync(int?pageSize, int?pageNumber,
string orderBy)
{
var query = new GetOrdersQuery(pageNumber, pageSize)
{
OrderBy = orderBy
};
var result = await _mediator.Send(query);
return(result);
}
public async Task <Response <PagedList <OrderResource> > > Handle(GetOrdersQuery request, CancellationToken cancellationToken)
{
var orders = await orderRepo.GetOrderPerPageAsync(request);
if (orders.Any())
{
var orderResources = pagedConvertor.orderPagedToResource(orders);
return(Response.Ok <PagedList <OrderResource> >(orderResources));
}
return(Response.Fail <PagedList <OrderResource> >("سفارشی با این مشخصات یافت نشد", StatusCodeEnum.NOTFUOUND));
}
public async Task <IActionResult> GetOrders([FromRoute] Guid customerId)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var query = new GetOrdersQuery(customerId);
return(Response(await _mediator.Send(query)));
}
public async Task <IEnumerable <OrderDto> > Handle(GetOrdersQuery request, CancellationToken cancellationToken)
{
IDbConnection dbConnection = _sqlConnectionFactory.GetOpenConnection();
const string sql = "SELECT " +
"OrderId, " +
"Title " +
"FROM " +
"Orders";
IEnumerable <OrderDto> orders = await dbConnection.QueryAsync <OrderDto>(sql);
return(orders.ToList());
}
public GetOrdersQueryHandlerTest()
{
mapper = new Mock <IMapper>();
searchOrderService = new Mock <ISearchOrderService>();
query = new GetOrdersQuery(It.IsAny <FilteringData>());
queryHandler = new GetOrdersQueryHandler(searchOrderService.Object, mapper.Object);
orders = new List <Order> {
new Order(), new Order()
};
ordersDto = new List <GetOrdersDto> {
new GetOrdersDto(), new GetOrdersDto()
};
}
public void GetOrders_IncorrectClientId_Exception(int _clientId)
{
var testSessionToken = SessionRepository.StartNewSession(_clientId);
var getOrdersQuery = new GetOrdersQuery
{
sessionToken = testSessionToken,
};
var handler = new GetOrdersQueryHandler();
TestDelegate result = () => handler.Handle(getOrdersQuery);
SessionRepository.RemoveSession(testSessionToken);
Assert.Throws <Exception>(result);
}
public async Task <ResponseInfo <List <OrderDto> > > Handle(GetOrdersQuery request, CancellationToken cancellationToken)
{
var orders = await _uow.Repository <Order>().PagingAsync(
filter: x => x.StoreId == request.StoreId && x.OrderStatus == request.OrderStatus && x.InvoiceStatus == request.InvoiceStatus,
orderBy: m => m.OrderBy(x => x.OrderDate),
includes: null,
//new System.Linq.Expressions.Expression<Func<Order, object>>[1] { x => x.OrderDetails },
page: request.Page,
pageSize: request.PageSize
);
return(new ResponseInfo <List <OrderDto> >
{
Data = _mapper.Map <List <OrderDto> >(orders),
TotalCount = await _uow.Repository <Order>().CountAsync(x => x.StoreId == request.StoreId && x.OrderStatus == request.OrderStatus && x.InvoiceStatus == request.InvoiceStatus)
});
}
public async Task <DataTables <OrderDTO> > GetOrdersAsync(DataTableModel model)
{
var query = new GetOrdersQuery
{
PageSize = model.PageSize,
PageIndex = model.PageIndex,
OrderBy = model.OrderBy,
Draw = model.Draw,
Keyword = model.Keyword,
SortDirection = model.SortDirection
};
query.SetContext(User.Identity);
var plist = await OrderDF.GetOrdersAsync(query).ConfigureAwait(false);
return(new DataTables <OrderDTO>(query.Draw, plist));
}
public async Task <OrderList> GetList(int pageIndex, int pageSize)
{
PagingOptions paging = null;
if (pageIndex > 0 && pageSize > 0)
{
paging = new PagingOptions {
PageIndex = pageIndex, PageSize = pageSize
};
}
var query = new GetOrdersQuery {
PagingOptions = paging
};
var result = await queryBus.SendAsync(query);
return(mapper.Map(result));
}
public async Task <PagedList <OrderDto> > Handle(GetOrdersQuery request, CancellationToken cancellationToken)
{
var ordersCount = await _context.Orders.CountAsync();
var totalPages = (int)(Math.Ceiling(ordersCount / (double)request.PageSize));
var pageNumber = request.PageNumber > totalPages ? totalPages : request.PageNumber;
var amountToSkip = (pageNumber - 1) * request.PageSize;
var orders = await _context.Orders
.Skip(amountToSkip)
.Take(request.PageSize)
.ToListAsync();
var mappedOrders = _mapper.Map <IEnumerable <Order>, IEnumerable <OrderDto> >(orders);
var pagedResult = new PagedList <OrderDto>(mappedOrders, pageNumber, request.PageSize, ordersCount);
return(pagedResult);
}
public async Task <IEnumerable <OrderListModel> > Handle(GetOrdersQuery request, CancellationToken cancellationToken)
{
return(await dbContext.Orders
.Where(e => e.Status == OrderStatus.Confirmed)
.OrderByDescending(p => p.OrderDate)
.Select(e => new OrderListModel
{
InvoiceId = e.Invoice.Id,
OrderDate = e.OrderDate,
Quantity = e.OrderDetails.Quantity,
DispatchPlace = e.OrderDetails.Product.Supplier.City,
Product = new ProductDetail
{
Name = e.OrderDetails.Product.Name,
UnitPrice = e.OrderDetails.Product.UnitPrice,
},
TotalPrice = e.OrderDetails.Quantity * e.OrderDetails.UnitPrice
})
.ToListAsync(cancellationToken));
}
public void GetOrders_ClientDoesntExist_Exception(int _clientId)
{
DatabaseQueryProcessor.Erase();
Shared.FillTheDatabase();
int clientId = _clientId;
var testSessionToken = SessionRepository.StartNewSession(clientId);
var getOrdersQuery = new GetOrdersQuery
{
sessionToken = testSessionToken,
};
var handler = new GetOrdersQueryHandler();
TestDelegate result = () => handler.Handle(getOrdersQuery);
DatabaseQueryProcessor.Erase();
SessionRepository.RemoveSession(testSessionToken);
Assert.Throws <Exception>(result);
}
public Task <IEnumerable <OrderLookupModel> > Handle(GetOrdersQuery request, CancellationToken cancellationToken)
{
return(Task.FromResult(_context.Order
.Include(o => o.OrderState)
.Select(x => new OrderLookupModel
{
Id = x.Id,
ClientName = x.ClientName,
PhoneNumber = x.PhoneNumber,
Address = x.Address,
OrderState = x.OrderState,
OrderedItems = _context.OrderFoodOperation.Where(op => op.OrderId == x.Id).Include(op => op.Food)
.Select(op => new OrderedItemLookupModel
{
OperationId = op.Id,
FoodId = op.FoodId,
FoodName = op.Food.Name,
Quantity = op.Quantity
}).ToList()
}).OrderByDescending(x => x.Id).AsEnumerable()));
}
public Task <PagedList <OrderDTO> > GetOrdersAsync(GetOrdersQuery query)
{
var where = new StringBuilder();
if (query.Keyword.IsPresent())
{
where.AppendFormat(" AND (User LIKE '%{0}%' OR ASIN LIKE '%{0}%' OR SKU LIKE '%{0}%' OR Alias LIKE '%{0}%')", query.Keyword);
}
string orderBy = "CreatedOnUtc";
switch (query.OrderBy.GetValueOrDefault())
{
case 1:
orderBy = "User";
break;
case 2:
orderBy = "ASIN";
break;
case 3:
orderBy = "SKU";
break;
case 4:
orderBy = "Alias";
break;
case 5:
orderBy = "Status";
break;
}
orderBy += " " + query.SortDirection;
return(base.GetPagedListAsync <OrderDTO>(query.PageSize, query.PageIndex, "V_OrderList", "*", where.ToString(), orderBy));
}
public async Task <IActionResult> GetOrders([FromBody] GetOrdersQuery request)
{
return(Ok(await _mediator.Send(request)));
}
public async Task <ActionResult <GetOrdersQueryResponse> > GetOrders([FromRoute] GetOrdersQuery query, CancellationToken token) => await mediator.Query <GetOrdersQuery, GetOrdersQueryResponse>(query, token);
public async Task <IList <Order> > Handle(GetOrdersQuery request, CancellationToken cancellationToken) => ReadModelForOrderContext.Orders;
public async Task <ActionResult <List <OrderDto> > > GetOrders([FromHybrid] GetOrdersQuery query)
{
var result = await _mediator.Send(query);
return(Ok(result));
}
