public async Task <IActionResult> CreateOrderCartAsync([FromBody] OrderCartViewModel orderCartViewModel)
{
int userId;
int.TryParse(User.FindFirstValue(ClaimTypes.Sid), out userId);
return(new ObjectResult(await createOrderCartQuery.ExecutedAsync(userId, orderCartViewModel)));
}
public IActionResult ShowPreviousOrder(Order prevOrder)
{
var order = _context.Order.SingleOrDefault(o => o.OrderId == prevOrder.OrderId);
var carts = from c in _context.Cart
where c.ShoppingCartId == order.OrderShoppingCartId
select c;
List <Cart> cartList = new List <Cart>();
foreach (var cart in carts)
{
cartList.Add(cart);
}
OrderCartViewModel viewModel = null;
if (order != null)
{
viewModel = new OrderCartViewModel
{
ReceiverFirstName = order.FirstName,
ReceiverLastname = order.LastName,
OrderCreationDate = order.OrderCreationDate,
PreviousOrderId = order.OrderShoppingCartId,
Total = order.Total,
Carts = cartList
};
}
return(View(viewModel));
}
// GET: Order
public ActionResult Index()
{
OrderCart cart = OrderCart.GetOrder(this.HttpContext);
if (cart.GetOrderCount() > 0)
{
OrderCartViewModel vm = new OrderCartViewModel()
{
OrderItems = cart.GetOrderItems(),
OrderTotal = cart.GetOrderTotal()
};
return(View(vm));
}
else
{
OrderCartViewModel vm = new OrderCartViewModel()
{
OrderItems = cart.GetOrderItems(),
OrderTotal = cart.GetOrderTotal(),
Message = "No tickets ordered."
};
return(View(vm));
}
}
//Is called on checkout. We pass the Cart and an empty form to fill in to the View
public IActionResult Checkout()
{
OrderCartViewModel orderCartViewModel = new OrderCartViewModel();
orderCartViewModel.Carts = cart;
orderCartViewModel.Orders = new Order();
return(View(orderCartViewModel));
}
// GET: Order
public ActionResult Index()
{
var model = new OrderCartViewModel()
{
cart = Cart.Instance
};
return(View(model));
}
// GET: Order
public ActionResult Index()
{
OrderCart cart = OrderCart.GetCart(this.HttpContext);
OrderCartViewModel vm = new OrderCartViewModel()
{
OrderItems = cart.GetCartItems()
};
return(View(vm));
}
public IActionResult Cart()
{
var orders = this.orderService.GetAll();
var viewModel = new OrderCartViewModel
{
Ordes = (IEnumerable <OrderCreateViewModel>)orders,
};
return(this.View(viewModel));
}
// GET: Order
public ActionResult Index()
{
OrderCart order = OrderCart.GetOrder(this.HttpContext);
OrderCartViewModel vm = new OrderCartViewModel();
//{
// OrderItems = order.GetOrderItems(); // This doesn'd take any parameter
// OrderTotal = GetOrderTotal()
// }
return(View());
}
public async Task <IActionResult> Create([Bind("Carts,Orders")] OrderCartViewModel orderCartViewModel)
{
if (ModelState.IsValid)
{
_context.Add(orderCartViewModel.Orders);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index), new { id = orderCartViewModel.Orders.OrderId }));
}
return(View(orderCartViewModel));
}
//
// GET: /OrderCart/
public ActionResult Index()
{
var cart = OrderCart.GetCart(this.HttpContext);
// Set up our ViewModel
var viewModel = new OrderCartViewModel
{
CartItems = cart.GetCartItems(),
CartTotal = cart.GetTotal()
};
// Return the view
return(View(viewModel));
}
public ActionResult Cart()
{
var model = new OrderCartViewModel();
if (ItemsInCart() > 0)
{
model.Events = GetEventsInCart();
model.Total = GetTotal(model.Events);
}
ViewData["Title"] = "Cart";
return(View(model));
}
public ActionResult PrevOrders()
{
//var viewModels = new List<PreviousOrder>();
//var CartItems = db.CartItemBases
// .Include(cib => cib.Customer)
// .Where(cib => cib.Customer.Email == this.HttpContext.User.Identity.Name)
// .Include(cib => cib.Dish)
// .Include(cib => cib.Restaurant)
// .ToList();
//for (int i = 0; i < CartItems.Count(); i++)
//{
// var viewModel = new PreviousOrder();
// viewModel.OrderID = CartItems[i].OrderID;
// viewModel.DishName = CartItems[i].Dish.DishName;
// viewModel.RestaurantName = CartItems[i].Restaurant.UserName;
// viewModel.Quantity = CartItems[i].DishAmount;
// viewModel.TotalPrice = CartItems[i].TotalPrice;
// viewModel.OrderDate = CartItems[i].Order.OrderDate;
// viewModels.Add(viewModel);
//}
//return View(viewModels.OrderBy(v => v.OrderDate).ToList());
var orders = new List <Order>();
orders = db.Orders
.Include(o => o.Customer)
.Where(o => o.Customer.Email == this.HttpContext.User.Identity.Name)
.Include(o => o.Cart)
.OrderByDescending(o => o.OrderDate)
.ToList();
var viewModel = new OrderCartViewModel();
//viewModel.Restaurants = db.Restaurants;
//viewModel.Dishes = db.Dishes;
viewModel.CartItems = db.CartItemBases
.Include(cib => cib.Customer)
.Where(cib => cib.Customer.Email == this.HttpContext.User.Identity.Name)
.ToList();
//viewModel.Customers = db.Customers;
viewModel.Orders = orders;
return(View(viewModel));
}
/// <summary>
/// Create order
/// </summary>
/// <param name="model"></param>
/// <returns></returns>
public virtual async Task <ResultModel <Guid> > CreateOrderAsync(OrderCartViewModel model)
{
if (model == null)
{
throw new NullReferenceException();
}
if (model.CartId == null)
{
return(new NotFoundResultModel <Guid>());
}
var cartRequest = await _cartService.GetCartByIdAsync(model.CartId);
if (!cartRequest.IsSuccess)
{
return(cartRequest.Map(Guid.Empty));
}
var cart = cartRequest.Result;
var order = OrderMapper.Map(cart, model.Notes);
var currency = (await _productService.GetGlobalCurrencyAsync()).Result;
order.CurrencyId = currency.Code;
await _orderDbContext.Orders.AddAsync(order);
var dbRequest = await _orderDbContext.PushAsync();
if (dbRequest.IsSuccess)
{
OrderEvents.Orders.OrderCreated(new AddOrderEventArgs
{
Id = order.Id,
OrderStatus = order.OrderState.ToString()
});
}
_commerceContext.CartItems.RemoveRange(cart.CartItems);
await _commerceContext.PushAsync();
return(dbRequest.Map(order.Id));
}
public ActionResult Index(OrderCartViewModel orderCart, HttpPostedFileBase upload)
{
orderCart.cart = Cart.Instance;
if (ModelState.IsValid)
{
byte[] avatar = null;
if (upload != null)
{
avatar = new byte[upload.ContentLength];
upload.InputStream.Read(avatar, 0, upload.ContentLength);
}
var order = new Order()
{
Id = Guid.NewGuid(),
UserName = orderCart.UserName,
UserPhone = orderCart.UserPhone,
UserComment = orderCart.UserComment,
UserAvatar = avatar,
UserId = Guid.NewGuid(),
CreateDate = DateTime.Now,
};
var orderProducts = new List <OrderProduct>();
foreach (var item in orderCart.cart.Items)
{
orderProducts.Add(new OrderProduct {
Id = Guid.NewGuid(), OrderId = order.Id, ProductId = item.Prod.Id, Price = item.Prod.Price, Quantity = item.Quantity
});
}
_dataService.SaveOrder(order, orderProducts);
Cart.Instance.RemoveAll();
return(Redirect("/Products"));
}
return(View(orderCart));
}
public ActionResult Confirmation(OrderCartViewModel order)
{
var session = HttpContext.Session;
var cart = session.Get <Order>("Cart");
var tApi = new TransactionApi(_apiSettings.ApiBaseUrl);
var userId = "";
if (User.Identity.IsAuthenticated)
{
userId = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
}
var transaction = new Transaction
{
TransactionID = 0,
BuyerFirstName = order.BuyerFirstName,
BuyerLastName = order.BuyerLastName,
BuyerAddress = order.BuyerAddress,
BuyerCity = order.BuyerCity,
BuyerEmail = order.BuyerEmail,
BuyerUserId = userId,
TotalAmount = order.TotalAmount
};
//Add transaction & process payment
Transaction newTransaction = tApi.AddTransaction(transaction);
if (newTransaction.PaymentStatus == "PaymentApproved")
{
var ticketApi = new TicketApi(_apiSettings.ApiBaseUrl);
foreach (int id in cart.Cart)
{
var t = new Ticket
{
TicketEventDateID = id,
TransactionID = newTransaction.TransactionID
};
ticketApi.AddTicketOrder(t);
}
var a = new EmailSender();
var msg = @"Hello, <br/> Thank you for your ticket purchase with us.<br/>" +
"Receipt:<br/>" +
"TransactionID: " + newTransaction.TransactionID +
"Total tickets bought: " + cart.Cart.Count() +
"Total Amount paid: " + newTransaction.TotalAmount;
a.SendEmailAsync(newTransaction.BuyerEmail, "Thank you for your ticket purchase", msg);
ViewData["noTickets"] = cart.Cart.Count();
session.Remove("Cart");
}
switch (newTransaction.PaymentStatus)
{
case "PaymentRejected":
ViewData["panel-class"] = "panel-warning";
ViewData["PaymentStatus"] = "Payment Rejected";
break;
case "UnknownError":
ViewData["panel-class"] = "panel-danger";
ViewData["PaymentStatus"] = "Unknown Error";
break;
default:
ViewData["panel-class"] = "panel-success";
ViewData["PaymentStatus"] = "Payment Approved";
break;
}
ViewData["Title"] = "Payment Summary";
return(View(newTransaction));
}
public async Task <IActionResult> CreateOrder([Required] OrderCartViewModel model)
{
var createOrderRequest = await _orderProductService.CreateOrderAsync(model);
return(Json(createOrderRequest));
}
public async Task <bool> ExecutedAsync(int userId, OrderCartViewModel orderCartViewModel)
{
try
{
Data.Entities.Order order = new Data.Entities.Order();
if (userId != 0)
{
order.CreatedBy = userId;
orderCartViewModel.ShipmentDetail.UserId = userId;
}
if (await db.ShipmentDetails.AnyAsync(x => x.Id == orderCartViewModel.ShipmentDetail.Id))
{
order.ShipmentDetailId = orderCartViewModel.ShipmentDetail.Id;
}
else
{
order.ShipmentDetail = orderCartViewModel.ShipmentDetail;
}
foreach (CartItemViewModel item in orderCartViewModel.CartItems)
{
if (await db.Products.Where(x => x.Id == item.Id).AnyAsync(x => x.Quantity.GetValueOrDefault() < orderCartViewModel.CartItems.Count))
{
return(false);
}
order.OrderDetails.Add(new OrderDetail()
{
ProductId = item.Id,
Count = item.Count,
Price = item.Price,
PromotionPrice = item.PromotionPrice
});
}
order.DeliveryMethod = orderCartViewModel.DeliveryMethod.Name;
order.TotalShipping = orderCartViewModel.DeliveryMethod.Cost;
order.PaymentMethod = orderCartViewModel.PaymentMethod;
order.Ordered = DateTime.Now;
order.Status = 1;
db.Orders.Add(order);
string body = File.ReadAllText("./Templates/MailOrderInformationTemplate.html");
body = body.Replace("@Name", orderCartViewModel.ShipmentDetail.Name);
body = body.Replace("@Status", "được đặt");
body = body.Replace("@Time", DateTime.Now.ToString("dd/MM/yyyy HH:mm"));
await sendMail.ExecutedAsync(orderCartViewModel.ShipmentDetail.Email, "Order information", body);
await db.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
return(false);
}
}
