public async Task <IActionResult> AddBookToOrder([Bind("BookId,BookAmount,OrderId")] BookOrderViewModel model)
{
if (ModelState.IsValid)
{
var order = await _context.Orders.FindAsync(model.OrderId);
var book = await _context.Books.FindAsync(model.BookId);
if (book == null)
{
return(BadRequest($"Book with id {model.BookId} does not exists."));
}
if (order == null)
{
return(BadRequest($"Order with id {model.OrderId} does not exists."));
}
order.BookOrders.Add(new BookOrder
{
Book = book,
Order = order,
BookAmount = model.BookAmount
});
order.TotalPrice += book.Price * model.BookAmount;
await _context.SaveChangesAsync();
}
return(RedirectToAction("Create", new { id = model.OrderId }));
}
public HttpResponseMessage OrderBook(BookOrderViewModel model)
{
try
{
Book Book = this._uow.Books.Get(model.BookId);
if (Book == null)
{
//Throw 404 (Not Found) exception if File not found.
ModelState.AddModelError("Error", string.Format("Book not found: {0} .", model.BookId));
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, ModelState));
}
OrderBook order = new OrderBook(Book, model.Quantity);
//List of orders
List <OrderBook> cart = new List <OrderBook>();
//If session does not exists then add order
if (!SessionExists("cart"))
{
cart.Add(order);
}
else
//if session already exists
{
cart = (List <OrderBook>)HttpContext.Current.Session["cart"];
var OrderToChange = cart.FirstOrDefault(x => x.Book.IdBook == Book.IdBook);
//check if order is already in card
//if order is in shopping card increment Quantity if not add new order
if (OrderToChange != null)
{
OrderToChange.Quantity++;
}
else
{
cart.Add(order);
}
}
HttpContext.Current.Session["cart"] = cart;
//successfully ordered
return(Request.CreateResponse(HttpStatusCode.OK, new { Quantity = cart.Sum(item => item.Quantity) }));
}
catch (Exception e)
{
ModelState.AddModelError("Error", "Unrecognised issue: " + e.Message);
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
public async Task <BaseResponse> OrderBook(BookOrderViewModel model)
{
var order = await mediator.Send(new BookOrderCommand { BookOrder = model });
return(ApiResponse.OK(order));
}
public async Task <string> OrderBook(BookOrderViewModel orderViewModel)
{
// here we just generate order id in code.
// we can also use navigation property and let ef generate id for us, but it would be another topic.
var bookOrder = new BookOrder
{
Id = Guid.NewGuid().ToString(),
OrderDetails = new List <BookOrderDetail>()
};
foreach (var detail in orderViewModel.OrderDetails)
{
bookOrder.OrderDetails
.Add(new BookOrderDetail
{
Sn = detail.Sn,
Count = detail.Count,
OrderId = bookOrder.Id
});
}
var sns = orderViewModel.OrderDetails.Select(o => o.Sn)
.OrderBy(x => x)
.ToList();
var lockKey = string.Join(",", sns);
using var distributedLock = await distributedLockProvider.Acquire(lockKey);
var stocks = await bookContext.BookStocks
.Where(s => sns.Contains(s.Sn))
.ToListAsync();
var errors = new List <string>();
foreach (var book in orderViewModel.OrderDetails)
{
var stock = stocks.Find(s => s.Sn == book.Sn);
if (stock == null)
{
errors.Add($"book {book.Sn} doesn't exist in stock.");
continue;
}
if (stock.StockCount < book.Count + stock.FreezeStock)
{
errors.Add($"book {book.Sn} doesn't have enough stock.");
continue;
}
stock.FreezeStock += book.Count;
}
if (errors.Any())
{
throw new DomainException(string.Join(",", errors));
}
bookContext.BookOrders.Add(bookOrder);
await bookContext.SaveChangesAsync();
await Task.Delay(500);
await mediator.Send(new StockOrderCommand
{
BookStock = new BookStockViewModel
{
OrderId = bookOrder.Id,
StockViewModels = orderViewModel.OrderDetails
.Select(o => new StockViewModel {
Sn = o.Sn, Count = o.Count
})
.ToList()
}
});
return(bookOrder.Id);
}
