public void PlaceOrder(OrderHistoryDto order)
{
// Save to Orders
_orderRepository.PlaceOrder(Mapper.Map <OrderHistoryDto, Orders>(order));
// Deduct from inventory
_pantryStockRepository.UpdatePantryStocks(order.DrinkId, order.OfficeId);
}
private async Task <OrderHistoryDto> PopulateOrderItemsAsync(OrderHistoryDto orderHistoryDto)
{
var orderItemsPath = string.Format("{0}{1}/{2}", HttpClientProvider.HttpClient.BaseAddress,
OrderItemsHistoryByOrderHistoryId_Url, _appUserId);
if (orderHistoryDto.OrderItems.Count == 0)
{
orderHistoryDto.OrderItems = (await _apiClient.ListAsync <OrderItemHistoryDto>(orderItemsPath)).ToList();
}
return(orderHistoryDto);
}
public async Task <IActionResult> ConfirmOrder()
{
var orderItems = _orderItemBasket.OrderItems;
var order = await CreateOrderAsync(orderItems);
var path = string.Format("{0}{1}", HttpClientProvider.HttpClient.BaseAddress, Orders_Base_Address);
var pathOrderHistory = string.Format("{0}{1}", HttpClientProvider.HttpClient.BaseAddress, Order_History_Base_Address);
var appUserId = order.AppUserId;
var pathAppUser = string.Format("{0}/{1}", AppUsers_Base_Address, appUserId);
var appUser = await _apiClient.GetAsync <AppUserDto>(pathAppUser);
var orderPostResult = await _apiClient.PostAsync(path, _mapper.Map <OrderDto>(order));
var orderhistoryToHistory = await _itemsHistoryComparer.GetOrderHistoryToRecordAsync(appUser, orderItems);
var newOrderHistory = new OrderHistoryDto();
if (orderhistoryToHistory.Count > 0 && appUser.OrderHistoryCount < 5)
{
appUser.OrderHistoryCount += 1;
newOrderHistory = _mapper.Map <OrderHistoryDto>(order);
newOrderHistory.OrderItems = _mapper.Map <IEnumerable <OrderItemHistoryDto> >(orderhistoryToHistory).ToList();
var orderhistoryPostResult = await _apiClient.PostAsync(pathOrderHistory, newOrderHistory);
await _apiClient.PutAsync(pathAppUser, appUser);
}
//if (appUser.OrderHistoryCount < 5)
//{
// appUser.OrderHistoryCount += 1;
// await _apiClient.PutAsync(pathAppUser, appUser);
//}
var confirmedOrder = _mapper.Map <OrderViewModel>(orderPostResult);
return(View(confirmedOrder));
}
public static OrderHistoryDto MapOrderToHistoryDto(this Order order)
{
var orderHistory = new OrderHistoryDto()
{
Id = order.Id,
//Client = order.Client,
FinalPrice = order.FinalPrice,
Items = order.Items.Select(i => new OrderItemHistoryDto()
{
Flavor1 = i.Flavor1.MapFlavorToDto(),
Flavor2 = i.Flavor2.MapFlavorToDto(),
Price = i.Price,
Quantity = i.Quantity
}).ToList()
};
return(orderHistory);
}
public async Task <ActionResult <OrderHistoryDto> > PostOrderHistory(OrderHistoryDto orderHistory)
{
if (ModelState.IsValid)
{
try
{
await _orderHistoryRepository.AddAsync(_mapper.Map <OrderHistory>(orderHistory));
await _unitOfWorkOrderhistory.CommitAsync(_cancellationToken);
return(CreatedAtAction("GetOrderHistory", new { id = orderHistory.OrderHistoryId }, orderHistory));
}
catch (Exception ex)
{
var errorMsg = ex.Message;
throw;
}
}
return(BadRequest());
}
public void PlaceOrder([FromBody] OrderHistoryDto order)
{
order.DateOrdered = DateTime.UtcNow;
_orderApiService.PlaceOrder(order);
}
