public ActionResult OrderCreatedResult()
{
if (!AccessToken.Valid())
{
return(RedirectToAction("Login", "Account"));
}
bool created = (bool)TempData["OrderStatus"];
if (!created)
{
ViewBag.Created = false;
ViewBag.Message = "Error: could not create order";
return(View());
}
Cart cart = TempData["Cart"] as Cart;
OrderDetailsDTO order = TempData["CreatedOrder"] as OrderDetailsDTO;
if (cart == null || cart.CartItems.Count == 0 || order == null)
{
return(RedirectToAction("Index", "Book"));
}
//Set availability: it will be used in the view to show which items were not orderd
//clear available flag
cart.CartItems.ForEach((c) => c.IsAvailable = false);
// set available flag based on order items
// in case it is not ordered set isavailable to false
foreach (var item in cart.CartItems)
{
if (order.OrderItemsDTO.FirstOrDefault((b) => b.BookId == item.Book.Id) != null)
{
item.IsAvailable = true;
}
}
if (cart.CartItems.Count() == order.OrderItemsDTO.Count())
{
ViewBag.Message = "All items were orderd";
}
else
{
ViewBag.Message = "Some items were not orderd!";
}
ViewBag.Created = true;
OrderCreatedViewModel orderCreatedViewModel = new OrderCreatedViewModel();
orderCreatedViewModel.OrderDetailsDTO = order;
orderCreatedViewModel.CartItems = cart.CartItems;
return(View(orderCreatedViewModel));
}
public async Task <bool> SendOrderCreatedEmailAsync(AppUser user, Order order)
{
if (user == null)
{
return(false);
}
var host = "http://zhinindas.alchemy.shop.axmouth.dev";
var model = new OrderCreatedViewModel(user, order, host);
var name = "OrderCreated";
var htmlBody = await _renderer.RenderViewToStringAsync($"{templateBaseDir}/{name}/{name}Html.cshtml", model);
var textBody = await _renderer.RenderViewToStringAsync($"{templateBaseDir}/{name}/{name}Text.cshtml", model);
var result = await SendEmailAsync(new List <string> {
user.Email
}, _fromAddress, "Your Order has been created", textBody, htmlBody);
return(result);
}
public async Task <ActionResult <OrderCreatedViewModel> > CreateOrder(CreateOrderViewModel createOrderViewModel)
{
var purchaseSettings = await purchaseSettingsRepository.GetAsync();
switch (createOrderViewModel.PaymentMethod)
{
case PaymentMethod.Dotpay:
if (purchaseSettings.IsDotpayAvaible)
{
break;
}
return(BadRequest(new ValidationErrors("Dotpay is not enabled.")));
case PaymentMethod.Cash:
if (purchaseSettings.IsCashAvaible)
{
break;
}
return(BadRequest(new ValidationErrors("Cash is not enabled")));
case PaymentMethod.BankTransfer:
if (purchaseSettings.IsTransferAvaible)
{
break;
}
return(BadRequest(new ValidationErrors("Bank transfer is not enabled")));
}
if (createOrderViewModel.DeliveryMethod == DeliveryMethod.Shipping)
{
if (!purchaseSettings.IsShippingAvaible)
{
return(BadRequest(new ValidationErrors("Shipping is not enabled")));
}
if (createOrderViewModel.DeliveryAddress == null)
{
return(BadRequest(new ValidationErrors("Address is required with delivery method shipping")));
}
}
if (createOrderViewModel.DeliveryMethod == DeliveryMethod.PersonalPickup)
{
if (!purchaseSettings.IsPersonalPickupAvaible)
{
return(BadRequest(new ValidationErrors("Perosonal pickup is not enabled.")));
}
if (!createOrderViewModel.PersonalPickupBranchId.HasValue)
{
return(BadRequest(new ValidationErrors("Branch id is required with delivery method personal pickup")));
}
}
var products = await productRepository.GetByIdsAsync(createOrderViewModel.Products.Select(p => p.ProductId));
if (products.Count != createOrderViewModel.Products.Count)
{
return(BadRequest(new ValidationErrors("Not all products exists")));
}
var errorsLit = new List <string>();
createOrderViewModel.Products.ForEach(p =>
{
var productFromDb = products.SingleOrDefault(x => x.Id == p.ProductId);
if (productFromDb.Quantity < p.ProductQuantity)
{
errorsLit.Add($"Not enough of {productFromDb.Name}, there is only {productFromDb.Quantity} left.");
}
});
if (errorsLit.Any())
{
return(BadRequest(new ValidationErrors(errorsLit)));
}
var orderProducts = new List <OrderProduct>();
var fullPrice = 0;
foreach (var product in products)
{
var quantity = createOrderViewModel.Products.SingleOrDefault(x => x.ProductId == product.Id).ProductQuantity;
orderProducts.Add(new OrderProduct
{
Name = product.Name,
Manufacturer = product.Manufacturer,
Quantity = quantity,
Price = product.Price,
FirstImage = product.FirstImage
});
if (product.IsOnDiscount)
{
fullPrice += product.DiscountPrice.Value * quantity;
}
else
{
fullPrice += product.Price * quantity;
}
}
var order = new Order
{
DeliveryMethod = createOrderViewModel.DeliveryMethod,
PaymentMethod = createOrderViewModel.PaymentMethod,
EmailAddress = createOrderViewModel.EmailAddress,
Firstname = createOrderViewModel.Firstname,
Surname = createOrderViewModel.Surname,
PhoneNumber = createOrderViewModel.PhoneNumber,
PersonalPickupBranchId = createOrderViewModel.PersonalPickupBranchId,
City = createOrderViewModel.DeliveryAddress?.City,
PostalCode = createOrderViewModel.DeliveryAddress?.PostalCode,
Street = createOrderViewModel.DeliveryAddress?.Street,
StreetNumber = createOrderViewModel.DeliveryAddress?.StreetNumber,
Products = JsonSerializer.Serialize(orderProducts),
Price = fullPrice,
OrderStatus = OrderStatus.Created,
DateTime = DateTime.Now
};
await orderRepository.CreateAsync(order);
var response = new OrderCreatedViewModel
{
PaymentMethod = order.PaymentMethod,
};
if (order.PaymentMethod == PaymentMethod.Dotpay)
{
response.Message = $"Order successful transaction id: {order.Id}.";
var callbackUrl = $"https://{HttpContext.Request.Host}/api/Order/dotpay-callback";
response.DotPayRedirectLink = dotPayService.CreatePaymentTransactionUri(order.Id, order.Price, order.EmailAddress, callbackUrl);
}
else if (order.PaymentMethod == PaymentMethod.BankTransfer)
{
response.Message = $"Order successful transaction id: {order.Id}, please send cash to: {purchaseSettings.TransferNumber}.";
}
else
{
response.Message = $"Order successful transaction id: {order.Id}, you will be notified, with futher actions.";
}
_ = sendgridService.SendOrderConfirmationEmail(order.EmailAddress, response.Message);
return(Ok(response));
}
