public IActionResult Complete(int id)
{
this.orderService.Complete(id);
var order = this.orderService.GetOrder(id);
var model = new GetOrderViewModel {
Order = order
};
return(this.View(model));
}
public async Task <ActionResult <GetOrderViewModel> > GetOrder(Guid id)
{
var order = await _context.Order
.Include(o => o.DeliveryAddress)
.Include(o => o.InvoiceAddress)
.Include(o => o.DeliveryAddress.City)
.Include(o => o.InvoiceAddress.City)
.Include(o => o.Products)
.FirstOrDefaultAsync(o => o.OrderId == id);
if (order == null)
{
return(NotFound());
}
var getOrderViewModel = new GetOrderViewModel(order);
return(getOrderViewModel);
}
public IActionResult ViewDetails(int orderId)
{
if (orderId != 0)
{
var order = orderAppService.GetOrders().FirstOrDefault(i => i.Id == orderId);
var customer = customerAppService.GetAllCustomers().FirstOrDefault(i => i.Id == order.CustomerId);
var model = new GetOrderViewModel()
{
OrderId = order.Id,
OrderDate = order.OrderDate,
OrderTotal = order.OrderTotal,
OrderItems = mapper.Map <List <OrderItemDto> >(order.OrderItems),
CustomerId = order.CustomerId,
CustomerName = customer.CustomerName
};
return(View(model));
}
return(NotFound());
}
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));
}
