public IActionResult Index()
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
ShoppingCartVM = new ShoppingCartVM()
{
OrderHeader = new Models.OrderHeader(),
ListCart = _unitOfWork.ShoppingCart.GetAll(u => u.ApplicationUserId == claim.Value, includeProperties: "Product")
};
ShoppingCartVM.OrderHeader.OrderTotal = 0;
ShoppingCartVM.OrderHeader.ApplicationUser = _unitOfWork.ApplicationUser
.GetFirstOrDefault(u => u.Id == claim.Value);
foreach (var list in ShoppingCartVM.ListCart)
{
list.Price = list.Product.Price;
ShoppingCartVM.OrderHeader.OrderTotal += (list.Price * list.Count);
list.Product.Description = StaticDetail.ConvertToRawHtml(list.Product.Description);
if (list.Product.Description.Length > 100)
{
list.Product.Description = list.Product.Description.Substring(0, 99) + "...";
}
}
return(View(ShoppingCartVM));
}
public async Task <IActionResult> Index()
{
cartDetails = new OrderDetailsCart()
{
Order = new Models.Order()
};
cartDetails.Order.OrderTotal = 0;
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
var cart = db.Cart.Where(c => c.UserId == claim.Value);
if (cart != null)
{
cartDetails.listCart = cart.ToList();
}
foreach (var list in cartDetails.listCart)
{
list.Service = await db.Service.FirstOrDefaultAsync(m => m.Id == list.ServiceId);
cartDetails.Order.OrderTotal = cartDetails.Order.OrderTotal + (list.Service.Price * list.Count);
list.Service.Description = StaticDetail.ConvertToRawHtml(list.Service.Description);
if (list.Service.Description.Length > 100)
{
list.Service.Description = list.Service.Description.Substring(0, 99) + "...";
}
}
cartDetails.Order.OrderTotalOriginal = cartDetails.Order.OrderTotal;
if (HttpContext.Session.GetString(StaticDetail.ssCouponCode) != null)
{
cartDetails.Order.CouponCode = HttpContext.Session.GetString(StaticDetail.ssCouponCode);
var couponFromDb = await
db.Coupon
.Where(c => c.Name.ToLower() ==
cartDetails.Order.CouponCode.ToLower()).FirstOrDefaultAsync();
if (couponFromDb != null)
{
cartDetails.Order.OrderTotal =
StaticDetail.DiscountedPrice(couponFromDb, cartDetails.Order.OrderTotalOriginal);
}
else
{
HttpContext.Session.SetString(StaticDetail.ssCouponCode, string.Empty);
}
}
return(View(cartDetails));
}
public async Task <IActionResult> Summary()
{
detailCart = new OrderDetailsCart()
{
OrderHeader = new Models.OrderHeader(),
};
detailCart.OrderHeader.OrderTotal = 0m;
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
ApplicationUser applicationUser = await this.db.ApplicationUser.Where(c => c.Id == claim.Value).FirstOrDefaultAsync();
var cart = this.db.ShoppingCart.Where(c => c.ApplicationUserId == claim.Value);
if (cart != null)
{
detailCart.listCart = cart.ToList();
}
foreach (var list in detailCart.listCart)
{
list.MenuItem = await this.db.MenuItems.FirstOrDefaultAsync(m => m.Id == list.MenuItemId);
detailCart.OrderHeader.OrderTotal = detailCart.OrderHeader.OrderTotal + ((decimal)list.MenuItem.Price * list.Count);
}
detailCart.OrderHeader.OrderTotalOriginal = detailCart.OrderHeader.OrderTotal;
detailCart.OrderHeader.PickUpName = applicationUser.Name;
detailCart.OrderHeader.PhoneNumber = applicationUser.PhoneNumber;
detailCart.OrderHeader.PickUpTime = DateTime.Now;
if (HttpContext.Session.GetString(StaticDetail.ssCouponCode) != null)
{
detailCart.OrderHeader.CouponCode = HttpContext.Session.GetString(StaticDetail.ssCouponCode);
var couponFromDb = await this.db.Coupons.Where(c => c.Name.ToLower() == detailCart.OrderHeader.CouponCode.ToLower()).FirstOrDefaultAsync();
detailCart.OrderHeader.OrderTotal = (decimal)StaticDetail.DiscountedPrice(couponFromDb, detailCart.OrderHeader.OrderTotalOriginal);
}
return(View(detailCart));
}
public async Task <IActionResult> Index()
{
detailCart = new OrderDetailsCart()
{
OrderHeader = new Models.OrderHeader(),
};
detailCart.OrderHeader.OrderTotal = 0m;
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
var cart = this.db.ShoppingCart.Where(c => c.ApplicationUserId == claim.Value);
if (cart != null)
{
detailCart.listCart = cart.ToList();
}
foreach (var list in detailCart.listCart)
{
list.MenuItem = await this.db.MenuItems.FirstOrDefaultAsync(m => m.Id == list.MenuItemId);
detailCart.OrderHeader.OrderTotal = detailCart.OrderHeader.OrderTotal + ((decimal)list.MenuItem.Price * list.Count);
list.MenuItem.Description = StaticDetail.ConvertToRawHtml(list.MenuItem.Description);
if (list.MenuItem.Description.Length > 100)
{
list.MenuItem.Description = list.MenuItem.Description.Substring(0, 99) + "...";
}
}
detailCart.OrderHeader.OrderTotalOriginal = detailCart.OrderHeader.OrderTotal;
if (HttpContext.Session.GetString(StaticDetail.ssCouponCode) != null)
{
detailCart.OrderHeader.CouponCode = HttpContext.Session.GetString(StaticDetail.ssCouponCode);
var couponFromDb = await this.db.Coupons.Where(c => c.Name.ToLower() == detailCart.OrderHeader.CouponCode.ToLower()).FirstOrDefaultAsync();
detailCart.OrderHeader.OrderTotal = (decimal)StaticDetail.DiscountedPrice(couponFromDb, detailCart.OrderHeader.OrderTotalOriginal);
}
return(View(detailCart));
}
public async Task <IActionResult> Summary()
{
// get currentuser
var claimsIdentity = (ClaimsIdentity)this.User.Identity;
var claimUser = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
// getting user_name
ApplicationUser user = await _db.ApplicationUser.Where(s => s.Id == claimUser.Value).FirstOrDefaultAsync();
var shoppingCartData = _db.ShoppingCart.Where(s => s.ApplicationUserId == claimUser.Value);
orderDetailsCartViewModel = new OrderDetailsCartViewModel()
{
OrderHeader = new Models.OrderHeader()
};
orderDetailsCartViewModel.OrderHeader.OrderTotalOriginal = 0;
if (shoppingCartData != null)
{
orderDetailsCartViewModel.ListShoppingCarts = shoppingCartData.ToList();
}
foreach (var shoppingItem in orderDetailsCartViewModel.ListShoppingCarts)
{
shoppingItem.MenuItem = await _db.MenuItem.FirstOrDefaultAsync(s => s.Id == shoppingItem.MenuItemId);
// update the total price
orderDetailsCartViewModel.OrderHeader.OrderTotalOriginal += shoppingItem.MenuItem.Price * shoppingItem.Count;
}
orderDetailsCartViewModel.OrderHeader.OrderTotalDiscount = orderDetailsCartViewModel.OrderHeader.OrderTotalOriginal;
// use user name
orderDetailsCartViewModel.OrderHeader.PickupName = user.Name;
orderDetailsCartViewModel.OrderHeader.Phonenumber = user.PhoneNumber;
orderDetailsCartViewModel.OrderHeader.PickupTime = DateTime.Now;
if (HttpContext.Session.GetString(StaticDetail.ssCoupon) != null)
{
orderDetailsCartViewModel.OrderHeader.CouponCode = HttpContext.Session.GetString(StaticDetail.ssCoupon);
var couponFromDb = await _db.Coupon.Where(s => s.Name.ToLower() == orderDetailsCartViewModel.OrderHeader.CouponCode.ToLower())
.FirstOrDefaultAsync();
orderDetailsCartViewModel.OrderHeader.OrderTotalDiscount = StaticDetail.DiscountedPrice(couponFromDb, orderDetailsCartViewModel.OrderHeader.OrderTotalOriginal);
}
return(View(orderDetailsCartViewModel));
}
//GET
public async Task <IActionResult> Summary()
{
orderDetailsVM = new OrderDetailsCartViewModel()
{
Order = new Order()
};
orderDetailsVM.Order.OrderTotal = 0;
ApplicationUser applicationUser = await _unitOfWork.User.GetCurrentUser();
var cart = await _unitOfWork.ShoppingCart.GetShoppingCartListByUserId(applicationUser.Id);
if (cart != null)
{
orderDetailsVM.ListCart = cart.ToList();
}
foreach (var list in orderDetailsVM.ListCart)
{
list.MenuItem = await _unitOfWork.MenuItem.GetId(list.MenuItemId);
orderDetailsVM.Order.OrderTotal = orderDetailsVM.Order.OrderTotal + (list.MenuItem.Price * list.Count);
}
orderDetailsVM.Order.OrderTotalOriginal = orderDetailsVM.Order.OrderTotal;
orderDetailsVM.Order.PickupName = applicationUser.Name;
orderDetailsVM.Order.PhoneNumber = applicationUser.PhoneNumber;
orderDetailsVM.Order.PickUpTime = DateTime.Now;
if (HttpContext.Session.GetString(StaticDetail.ssCouponCode) != null)
{
orderDetailsVM.Order.CouponCode = HttpContext.Session.GetString(StaticDetail.ssCouponCode);
var couponFromDb = await _unitOfWork.Coupon.GetCouponCode(orderDetailsVM.Order.CouponCode);
orderDetailsVM.Order.OrderTotal = StaticDetail.DiscountedPrice(couponFromDb, orderDetailsVM.Order.OrderTotalOriginal);
}
return(View(orderDetailsVM));
}
public async Task <IActionResult> Index()
{
// retreive user
var claimIdentity = (ClaimsIdentity)this.User.Identity;
var currentUser = claimIdentity.FindFirst(ClaimTypes.NameIdentifier);
var shoppingCartData = _db.ShoppingCart.Where(s => s.ApplicationUserId == currentUser.Value);
orderDetailsCartViewModel = new OrderDetailsCartViewModel()
{
OrderHeader = new Models.OrderHeader()
};
orderDetailsCartViewModel.OrderHeader.OrderTotalOriginal = 0;
if (shoppingCartData != null)
{
orderDetailsCartViewModel.ListShoppingCarts = shoppingCartData.ToList();
}
//ConvertToRawHtml versus @Html.Raw(item.Description)
foreach (var orderItem in orderDetailsCartViewModel.ListShoppingCarts)
{
orderItem.MenuItem = await _db.MenuItem.FirstOrDefaultAsync(s => s.Id == orderItem.MenuItemId);
orderDetailsCartViewModel.OrderHeader.OrderTotalOriginal += (orderItem.MenuItem.Price * orderItem.Count);
orderItem.MenuItem.Description = StaticDetail.ConvertToRawHtml(orderItem.MenuItem.Description);
if (orderItem.MenuItem.Description.Length > 100)
{
orderItem.MenuItem.Description = orderItem.MenuItem.Description.Substring(0, 99) + "...";
}
}
orderDetailsCartViewModel.OrderHeader.OrderTotalDiscount = orderDetailsCartViewModel.OrderHeader.OrderTotalOriginal;
if (HttpContext.Session.GetString(StaticDetail.ssCoupon) != null)
{
orderDetailsCartViewModel.OrderHeader.CouponCode = HttpContext.Session.GetString(StaticDetail.ssCoupon);
var couponFromDb = await _db.Coupon.Where(s => s.Name.ToLower() == orderDetailsCartViewModel.OrderHeader.CouponCode.ToLower())
.FirstOrDefaultAsync();
orderDetailsCartViewModel.OrderHeader.OrderTotalOriginal = StaticDetail.DiscountedPrice(couponFromDb, orderDetailsCartViewModel.OrderHeader.OrderTotalOriginal);
}
return(View(orderDetailsCartViewModel));
}
public async Task <IActionResult> Index()
{
orderDetailsVM = new OrderDetailsCartViewModel()
{
Order = new Order()
};
orderDetailsVM.Order.OrderTotal = 0;
var getUserId = await _unitOfWork.User.GetCurrentUser();
var cart = await _unitOfWork.ShoppingCart.GetShoppingCartListByUserId(getUserId.Id);
if (cart != null)
{
orderDetailsVM.ListCart = cart.ToList();
}
foreach (var list in orderDetailsVM.ListCart)
{
list.MenuItem = await _unitOfWork.MenuItem.GetId(list.MenuItemId);
orderDetailsVM.Order.OrderTotal = orderDetailsVM.Order.OrderTotal + (list.MenuItem.Price * list.Count);
}
orderDetailsVM.Order.OrderTotalOriginal = orderDetailsVM.Order.OrderTotal;
if (HttpContext.Session.GetString(StaticDetail.ssCouponCode) != null)
{
orderDetailsVM.Order.CouponCode = HttpContext.Session.GetString(StaticDetail.ssCouponCode);
var couponFromDb = await _unitOfWork.Coupon.GetCouponCode(orderDetailsVM.Order.CouponCode);
orderDetailsVM.Order.OrderTotal = StaticDetail.DiscountedPrice(couponFromDb, orderDetailsVM.Order.OrderTotalOriginal);
}
return(View(orderDetailsVM));
}
public async Task <IActionResult> SummaryPost()
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
var getUserId = await _unitOfWork.User.GetCurrentUser();
var cartList = await _unitOfWork.ShoppingCart.GetShoppingCartListByUserId(getUserId.Id);
orderDetailsVM.ListCart = cartList.ToList();
orderDetailsVM.Order.PaymentStatus = StaticDetail.PaymentStatusApproved;
orderDetailsVM.Order.OrderDate = DateTime.Now;
orderDetailsVM.Order.UserId = claim.Value;
orderDetailsVM.Order.Status = StaticDetail.StatusSubmitted;
orderDetailsVM.Order.PickUpTime = Convert.ToDateTime(orderDetailsVM.Order.PickUpDate.ToShortDateString() + " " + orderDetailsVM.Order.PickUpTime.ToShortTimeString());
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
await _unitOfWork.OrderServices.CreateOrder(orderDetailsVM.Order);
orderDetailsVM.Order.OrderTotalOriginal = 0;
foreach (var item in orderDetailsVM.ListCart)
{
item.MenuItem = await _unitOfWork.MenuItem.GetId(item.MenuItemId);
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = orderDetailsVM.Order.Id,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
orderDetailsVM.Order.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
_db.OrderDetails.Add(orderDetails);
}
if (HttpContext.Session.GetString(StaticDetail.ssCouponCode) != null)
{
orderDetailsVM.Order.CouponCode = HttpContext.Session.GetString(StaticDetail.ssCouponCode);
var couponFromDb = await _unitOfWork.Coupon.GetCouponCode(orderDetailsVM.Order.CouponCode);
orderDetailsVM.Order.OrderTotal = StaticDetail.DiscountedPrice(couponFromDb, orderDetailsVM.Order.OrderTotalOriginal);
}
else
{
orderDetailsVM.Order.OrderTotal = orderDetailsVM.Order.OrderTotalOriginal;
}
orderDetailsVM.Order.CouponCodeDiscount = orderDetailsVM.Order.OrderTotalOriginal - orderDetailsVM.Order.OrderTotal;
_db.ShoppingCart.RemoveRange(orderDetailsVM.ListCart);
HttpContext.Session.SetInt32(StaticDetail.ssShoppingCartCount, 0);
await _emailSender.SendEmailAsync(_db.Users.Where(u => u.Id == claim.Value).FirstOrDefault().Email, "Food - Order Created " + orderDetailsVM.Order.Id.ToString(), "Order has been submitted successfully");
await _db.SaveChangesAsync();
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> PostSummary(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
cartDetails.listCart = await db.Cart.Where(c => c.UserId == claim.Value).ToListAsync();
cartDetails.Order.PaymentStatus = StaticDetail.PaymentStatusPending;
cartDetails.Order.OrderDate = DateTime.Now;
cartDetails.Order.UserId = claim.Value;
cartDetails.Order.Status = StaticDetail.PaymentStatusPending;
cartDetails.Order.PickupTime =
Convert.ToDateTime(cartDetails.Order.PickupDate.ToShortDateString() + " " +
cartDetails.Order.PickupTime.ToShortTimeString());
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
db.Order.Add(cartDetails.Order);
await db.SaveChangesAsync();
cartDetails.Order.OrderTotalOriginal = 0;
foreach (var item in cartDetails.listCart)
{
item.Service = await db.Service.FirstOrDefaultAsync(m => m.Id == item.ServiceId);
OrderDetails orderDetails = new OrderDetails()
{
ServiceId = item.ServiceId,
OrderId = cartDetails.Order.Id,
Description = item.Service.Description,
ServiceName = item.Service.Name,
Price = item.Service.Price,
Count = item.Count
};
cartDetails.Order.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
db.OrderDetails.Add(orderDetails);
}
if (HttpContext.Session.GetString(StaticDetail.ssCouponCode) != null)
{
cartDetails.Order.CouponCode = HttpContext.Session.GetString(StaticDetail.ssCouponCode);
var couponFromDb = await db.Coupon.Where(c => c.Name.ToLower() ==
cartDetails.Order.CouponCode.ToLower()).FirstOrDefaultAsync();
cartDetails.Order.OrderTotal =
StaticDetail.DiscountedPrice(couponFromDb, cartDetails.Order.OrderTotalOriginal);
HttpContext.Session.SetString(StaticDetail.ssCouponCode, string.Empty);
}
else
{
cartDetails.Order.OrderTotal = cartDetails.Order.OrderTotalOriginal;
}
cartDetails.Order.CouponCodeDiscount =
cartDetails.Order.OrderTotalOriginal - cartDetails.Order.OrderTotal;
await db.SaveChangesAsync();
db.Cart.RemoveRange(cartDetails.listCart);
HttpContext.Session.SetInt32(StaticDetail.ssServicesCount, 0);
await db.SaveChangesAsync();
var testc = cartDetails.Order.OrderTotal * 100;
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(cartDetails.Order.OrderTotal * 100),
Currency = "cad",
Description = "Order ID: " + cartDetails.Order.Id,
SourceId = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.BalanceTransactionId == null)
{
cartDetails.Order.PaymentStatus = StaticDetail.PaymentStatusRejected;
}
else
{
cartDetails.Order.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
await _emailSender
.SendEmailAsync(db.Users.Where(u => u.Id == claim.Value).FirstOrDefault().Email,
" Tycoon - Service has been booked " + cartDetails.Order.Id.ToString(),
" Your writing service request has been received. Please login to your account to track the order!");
cartDetails.Order.PaymentStatus = StaticDetail.PaymentStatusApproved;
cartDetails.Order.Status = StaticDetail.StatusSubmitted;
}
else
{
cartDetails.Order.PaymentStatus = StaticDetail.PaymentStatusRejected;
cartDetails.Order.Status = StaticDetail.StatusCancelled;
}
await db.SaveChangesAsync();
// return RedirectToAction("Index", "Home");
return(RedirectToAction("Confirm", "Order", new { id = cartDetails.Order.Id }));
}
public async Task <IActionResult> SummaryPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
detailCart.listCart = await this.db.ShoppingCart.Where(c => c.ApplicationUserId == claim.Value).ToListAsync();
detailCart.OrderHeader.PaymentStatus = StaticDetail.PaymentStatusPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = StaticDetail.PaymentStatusPending;
detailCart.OrderHeader.PickUpTime = Convert.ToDateTime(detailCart.OrderHeader.PickUpDate.ToShortDateString() + " " + detailCart.OrderHeader.PickUpTime.ToShortTimeString());
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
this.db.OrderHeader.Add(detailCart.OrderHeader);
await this.db.SaveChangesAsync();
detailCart.OrderHeader.OrderTotalOriginal = 0;
foreach (var item in detailCart.listCart)
{
item.MenuItem = await this.db.MenuItems.FirstOrDefaultAsync(m => m.Id == item.MenuItemId);
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = detailCart.OrderHeader.Id,
Description = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = (decimal)item.MenuItem.Price,
Count = item.Count
};
detailCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
this.db.OrderDetails.Add(orderDetails);
}
if (HttpContext.Session.GetString(StaticDetail.ssCouponCode) != null)
{
detailCart.OrderHeader.CouponCode = HttpContext.Session.GetString(StaticDetail.ssCouponCode);
var couponFromDb = await this.db.Coupons.Where(c => c.Name.ToLower() == detailCart.OrderHeader.CouponCode.ToLower()).FirstOrDefaultAsync();
detailCart.OrderHeader.OrderTotal = (decimal)StaticDetail.DiscountedPrice(couponFromDb, detailCart.OrderHeader.OrderTotalOriginal);
}
else
{
detailCart.OrderHeader.OrderTotal = detailCart.OrderHeader.OrderTotalOriginal;
}
detailCart.OrderHeader.CouponCodeDiscount = detailCart.OrderHeader.OrderTotalOriginal - detailCart.OrderHeader.OrderTotalOriginal;
await this.db.SaveChangesAsync();
this.db.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32(StaticDetail.ssShoppingCartCount, 0);
await this.db.SaveChangesAsync();
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Orders ID : " + detailCart.OrderHeader.Id,
Source = stripeToken,
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.BalanceTransactionId == null)
{
detailCart.OrderHeader.PaymentStatus = StaticDetail.PaymentStatusRejected;
}
else
{
detailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
this.emailSender.SendEmailAsync(this.db.Users.Where(u => u.Id == claim.Value).FirstOrDefault().Email, "UniverseRestaurant - Order Created " + detailCart.OrderHeader.Id.ToString(), "Order has been submitted siccessfuly.");
detailCart.OrderHeader.PaymentStatus = StaticDetail.PaymentStatusApproved;
detailCart.OrderHeader.Status = StaticDetail.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = StaticDetail.PaymentStatusRejected;
}
await this.db.SaveChangesAsync();
//return RedirectToAction("Index","Home");
return(RedirectToAction("Confirm", "Order", new { id = detailCart.OrderHeader.Id }));
}
public async Task <IActionResult> SummaryPost(string stripeToken)
{
// claim the current user
var claimIdentity = (ClaimsIdentity)User.Identity;
var claimUser = claimIdentity.FindFirst(ClaimTypes.NameIdentifier);
orderDetailsCartViewModel.ListShoppingCarts = await _db.ShoppingCart.Where(s => s.ApplicationUserId == claimUser.Value).ToListAsync();
// update orderheader
orderDetailsCartViewModel.OrderHeader.UserId = claimUser.Value;
orderDetailsCartViewModel.OrderHeader.OrderDate = DateTime.Now;
orderDetailsCartViewModel.OrderHeader.PaymentStatus = StaticDetail.PaymentStatusPending;
orderDetailsCartViewModel.OrderHeader.Status = StaticDetail.PaymentStatusPending;
orderDetailsCartViewModel.OrderHeader.PickupTime = Convert.ToDateTime(orderDetailsCartViewModel.OrderHeader.PickupDate.ToShortDateString() + " " + orderDetailsCartViewModel.OrderHeader.PickupTime.ToShortTimeString());
await _db.OrderHeader.AddAsync(orderDetailsCartViewModel.OrderHeader);
await _db.SaveChangesAsync();
orderDetailsCartViewModel.OrderHeader.OrderTotalOriginal = 0;
List <OrderDetail> orderDetailsList = new List <OrderDetail>();
foreach (var shoppingItem in orderDetailsCartViewModel.ListShoppingCarts)
{
shoppingItem.MenuItem = await _db.MenuItem.FirstOrDefaultAsync(s => s.Id == shoppingItem.MenuItemId);
OrderDetail orderdetail = new OrderDetail
{
MenuitemId = shoppingItem.MenuItemId,
OrderHeaderId = orderDetailsCartViewModel.OrderHeader.Id,
Description = shoppingItem.MenuItem.Description,
Name = shoppingItem.MenuItem.Name,
Price = shoppingItem.MenuItem.Price,
Count = shoppingItem.Count
};
orderDetailsCartViewModel.OrderHeader.OrderTotalOriginal += orderdetail.Price * orderdetail.Count;
await _db.OrderDetail.AddAsync(orderdetail);
}
if (HttpContext.Session.GetString(StaticDetail.ssCoupon) != null)
{
orderDetailsCartViewModel.OrderHeader.CouponCode = HttpContext.Session.GetString(StaticDetail.ssCoupon);
var couponFromDb = await _db.Coupon.Where(s => s.Name.ToLower() == orderDetailsCartViewModel.OrderHeader.CouponCode.ToLower())
.FirstOrDefaultAsync();
orderDetailsCartViewModel.OrderHeader.OrderTotalDiscount = StaticDetail.DiscountedPrice(couponFromDb, orderDetailsCartViewModel.OrderHeader.OrderTotalOriginal);
}
else
{
orderDetailsCartViewModel.OrderHeader.OrderTotalDiscount = orderDetailsCartViewModel.OrderHeader.OrderTotalOriginal;
}
orderDetailsCartViewModel.OrderHeader.CouponDiscount = orderDetailsCartViewModel.OrderHeader.OrderTotalOriginal - orderDetailsCartViewModel.OrderHeader.OrderTotalDiscount;
await _db.SaveChangesAsync();
// remove from shoppingcart since we are done with shopping
_db.ShoppingCart.RemoveRange(orderDetailsCartViewModel.ListShoppingCarts);
HttpContext.Session.SetInt32("ssCartCount", 0);
await _db.SaveChangesAsync();
// make trasnaction using stripe
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(orderDetailsCartViewModel.OrderHeader.OrderTotalDiscount * 100),
Currency = "usd",
Description = "Order ID: " + orderDetailsCartViewModel.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
// create service with options above
Charge charge = service.Create(options);
if (charge.BalanceTransactionId == null)
{
orderDetailsCartViewModel.OrderHeader.PaymentStatus = StaticDetail.PaymentStatusRejected;
}
else
{
orderDetailsCartViewModel.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
orderDetailsCartViewModel.OrderHeader.PaymentStatus = StaticDetail.PaymentStatusApproved;
orderDetailsCartViewModel.OrderHeader.Status = StaticDetail.OrderSubmitted;
}
else
{
orderDetailsCartViewModel.OrderHeader.PaymentStatus = StaticDetail.PaymentStatusRejected;
}
await _db.SaveChangesAsync();
// return RedirectToAction("Index", "Home");
// actioname, controller, pass param
return(RedirectToAction("Confirm", "Order", new { id = orderDetailsCartViewModel.OrderHeader.Id }));
}
