public async Task <IActionResult> PostOrder(PostOrderViewModel orderViewModel)
{
if (ModelState.IsValid)
{
// TODO Logic
Drink drinkSelected = null;
switch (orderViewModel.DrinkSelected)
{
case "COFFEE":
drinkSelected = new Coffee();
break;
case "THE":
drinkSelected = new The();
break;
case "CAPPUCCINO":
drinkSelected = new Cappuccino();
break;
}
var order = new Logic.Domain.Order(drinkSelected, orderViewModel.CoinInserted);
await _orderService.CreateOrderAsync(order);
return(Ok(new PostOrderResultViewModel {
Rest = order.Rest, IsWinner = order.IsWinner
}));
}
return(BadRequest(ModelState));
}
public async Task <IActionResult> PostOrder(string Id, PostOrderViewModel viewModel)
{
if (ModelState.IsValid)
{
var factor = await _db.FactorRepository.GetAsync(f => f.OrderId == Id, string.Empty);
if (factor == null)
{
return(NotFound());
}
factor.HasSent = true;
factor.PostTrackingCode = viewModel.PostTrackingCode;
_db.FactorRepository.Update(factor);
await _db.SaveAsync();
return(Redirect("/Admin/Factor"));
}
return(View(viewModel));
}
public async Task <ActionResult <GetOrderViewModel> > PostOrder(PostOrderViewModel model)
{
//VERIFY USER ROLE
//-------------------------------------------
var userId = User.FindFirst(ClaimTypes.NameIdentifier);
var user = await _context.Users.Include(u => u.Products).FirstOrDefaultAsync(u => u.Id == userId.Value);
//-------------------------------------------
//Extract Adresses
//-------------------------------------------
var invoiceAddress = AddressViewModel.GetAddress(model.InvoiceAddress);
var deliveryAddress = model.DeliveryAddress == null
? invoiceAddress
: AddressViewModel.GetAddress(model.DeliveryAddress);
//-------------------------------------------
var order = new Order
{
OrderId = Guid.NewGuid(),
Invoice_Id = Guid.NewGuid(),
Date = DateTime.Now,
PaymentMethod = model.PaymentMethod,
ShipmentMethod = model.ShipmentMethod,
OrderState = model.OrderState,
InvoiceAddress = invoiceAddress,
DeliveryAddress = deliveryAddress,
CustomerId = user?.Id
};
//Extract Products and add to Order
//------------------------------------------
if (model.Products == null || model.Products.Count == 0)
{
return(BadRequest("List of Product cant be null or empty"));
}
var counter = 0;
ICollection <SendRestockEmailParam> sendRestockEmailParams = new List <SendRestockEmailParam>();
ICollection <OrderProduct> orderProducts = new List <OrderProduct>();
ICollection <Product> products = new List <Product>();
foreach (var VARIABLE in model.Products)
{
var product = await _context.Product.FindAsync(VARIABLE.ProductId);
counter += VARIABLE.Cardinality;
if (product == null)
{
continue;
}
var cardinality = VARIABLE.Cardinality;
if (product.InStock - cardinality < 0)
{
return(BadRequest("Don't have that many in stock"));
}
if (product.IsDisabled)
{
return(BadRequest($"Product with ID: {product.ProductId} is Disabled"));
}
if ((product.InStock - cardinality) < product.MinStock)
{
sendRestockEmailParams.Add(new SendRestockEmailParam()
{
ManufacturerId = product.ManufacturerId,
ProductId = product.ProductId
});
}
product.InStock -= cardinality;
_context.Entry(product).State = EntityState.Modified;
//TODO Add Product to USerProductList if not already contained
if (user.Products == null)
{
user.Products = new List <Product> {
product
};
}
else if (user.Products.Any(p => p.ProductId == product.ProductId) != true)
{
user.Products.Add(product);
}
//_context.Entry(user).State = EntityState.Modified;
var orderProduct = new OrderProduct
{
Product = product,
Cardinality = cardinality,
OderProductId = Guid.NewGuid(),
ProductId = product.ProductId,
Order = order,
OrderId = order.OrderId
};
orderProducts.Add(orderProduct);
}
if (counter <= 0)
{
return(BadRequest("You have to Order sth"));
}
order.Products = orderProducts;
//Calculate total Cost
//TODO what about tax?
ICollection <decimal> costList = order.Products.Select(i => i.Cardinality * i.Product.Price).ToList();
foreach (var @decimal in costList)
{
order.TotalCost += @decimal;
}
//------------------------------------------
try
{
await _context.Order.AddAsync(order);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
throw;
}
try
{
await _mailService.SendOrderConfirmationEmailAsync(user, order);
await _mailService.SendInvoiceEmailAsync(user, order);
await SendRestockEmailManyAsync(sendRestockEmailParams);
}
catch (Exception e)
{
Console.WriteLine(e);
}
var getOrderViewModel = new GetOrderViewModel(order);
return(CreatedAtAction("GetOrder", new { id = order.OrderId }, getOrderViewModel));
}
