public async Task <IActionResult> SummaryPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
OrderDetailsCartVM.ShoppingCartsList = await db.shoppingCarts.Where(m => m.ApplicationUserId == claim.Value).ToListAsync();
OrderDetailsCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
OrderDetailsCartVM.OrderHeader.OrderDate = DateTime.Now;
OrderDetailsCartVM.OrderHeader.UserId = claim.Value;
OrderDetailsCartVM.OrderHeader.Status = SD.PaymentStatusPending;
OrderDetailsCartVM.OrderHeader.PickUpTime = Convert.ToDateTime(OrderDetailsCartVM.OrderHeader.PickUpDate.ToShortDateString() + " " +
OrderDetailsCartVM.OrderHeader.PickUpTime.ToShortTimeString());
OrderDetailsCartVM.OrderHeader.OrderTotalOrginal = 0;
db.OrderHeaders.Add(OrderDetailsCartVM.OrderHeader);
await db.SaveChangesAsync();
foreach (var item in OrderDetailsCartVM.ShoppingCartsList)
{
item.MenuItem = db.MenuItems.FirstOrDefault(m => m.Id == item.MenuItemId);
OrderDetail orderDetail = new OrderDetail()
{
MenuItemId = item.MenuItemId,
OrderId = OrderDetailsCartVM.OrderHeader.Id,
Description = item.MenuItem.Discription,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
OrderDetailsCartVM.OrderHeader.OrderTotal += item.MenuItem.Price * item.Count;
db.OrderDetails.Add(orderDetail);
}
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
OrderDetailsCartVM.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = db.Coupons.Where(m => m.Name.ToLower() == OrderDetailsCartVM.OrderHeader.CouponCode.ToLower()).FirstOrDefault();
OrderDetailsCartVM.OrderHeader.OrderTotal = SD.DiscountPrice(couponFromDb, OrderDetailsCartVM.OrderHeader.OrderTotalOrginal);
}
else
{
OrderDetailsCartVM.OrderHeader.OrderTotal = OrderDetailsCartVM.OrderHeader.OrderTotalOrginal;
}
OrderDetailsCartVM.OrderHeader.CouponCodeDiscount = OrderDetailsCartVM.OrderHeader.OrderTotalOrginal - OrderDetailsCartVM.OrderHeader.OrderTotal;
db.shoppingCarts.RemoveRange(OrderDetailsCartVM.ShoppingCartsList);
HttpContext.Session.SetInt32(SD.ShoppingCartCount, 0);
await db.SaveChangesAsync();
//online odeme icin
var options = new Stripe.ChargeCreateOptions
{
Amount = Convert.ToInt32(OrderDetailsCartVM.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + OrderDetailsCartVM.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.BalanceTransactionId == null)
{
OrderDetailsCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
OrderDetailsCartVM.OrderHeader.TrasactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
OrderDetailsCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
OrderDetailsCartVM.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
OrderDetailsCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
await db.SaveChangesAsync();
return(RedirectToAction("Index", "Home"));
}
public async Task <IActionResult> SummaryPost(string stripeToken)
{
//find the current user id
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
//retrieve all the shopping cart
detailCart.listCart = await _db.ShoppingCart.Where(c => c.ApplicationUserId == claim.Value).ToListAsync();
//modify the detailCart
//have not processed any payment yet
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = SD.PaymentStatusPending;
detailCart.OrderHeader.PickUpTime = Convert.ToDateTime(detailCart.OrderHeader.PickUpDate.ToShortDateString() + " " + detailCart.OrderHeader.PickUpTime.ToShortTimeString());
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
//we need OrderHeader Id to put data in OrderDetails so we need to add it first
_db.OrderHeader.Add(detailCart.OrderHeader);
await _db.SaveChangesAsync();
detailCart.OrderHeader.OrderTotalOriginal = 0;
foreach (var item in detailCart.listCart)
{
item.MenuItem = await _db.MenuItem.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 = item.MenuItem.Price,
Count = item.Count
};
detailCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
_db.OrderDetails.Add(orderDetails);
}
//before we input to database we need to compute the order total
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
detailCart.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = await _db.Coupon.Where(c => c.Name.ToLower() == detailCart.OrderHeader.CouponCode.ToLower()).FirstOrDefaultAsync();
detailCart.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, detailCart.OrderHeader.OrderTotalOriginal);
}
else
{
detailCart.OrderHeader.OrderTotal = detailCart.OrderHeader.OrderTotalOriginal;
}
detailCart.OrderHeader.CouponCodeDiscount = detailCart.OrderHeader.OrderTotalOriginal - detailCart.OrderHeader.OrderTotal;
//before we input to database we remove everything in session
_db.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32(SD.ssShoppingCartCount, 0);
await _db.SaveChangesAsync();
//payment transaction
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + detailCart.OrderHeader.Id,
Source = stripeToken
};
//make a charge
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.BalanceTransactionId == null)
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
detailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
//email for successful order
//email address , subject + id , message
await _emailSender.SendEmailAsync(_db.Users.Where(u => u.Id == claim.Value).FirstOrDefault().Email, "Spice - Order Created " + detailCart.OrderHeader.Id.ToString(), " Order has been submitted successfully.");
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
//after modfied the status
await _db.SaveChangesAsync();
return(RedirectToAction("Confirm", "Order", new { id = detailCart.OrderHeader.Id }));
//return RedirectToAction("Index", "Home");
}
public async Task <IActionResult> SummaryPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
detailCart.listCart = await _db.ShoppingCart.Where(c => c.ApplicationUserId == claim.Value).ToListAsync();
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = SD.PaymentStatusPending;
detailCart.OrderHeader.PickUpTime = Convert.ToDateTime(detailCart.OrderHeader.PickUpDate.ToShortDateString() + " " + detailCart.OrderHeader.PickUpTime.ToShortTimeString());
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
_db.OrderHeader.Add(detailCart.OrderHeader);
await _db.SaveChangesAsync();
detailCart.OrderHeader.OrderTotalOriginal = 0;
foreach (var item in detailCart.listCart)
{
item.MenuItem = await _db.MenuItem.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 = item.MenuItem.Price,
Count = item.Count
};
detailCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
_db.OrderDetails.Add(orderDetails);
}
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
detailCart.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = await _db.Coupon.Where(c => c.Name.ToLower() == detailCart.OrderHeader.CouponCode.ToLower()).FirstOrDefaultAsync();
detailCart.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, detailCart.OrderHeader.OrderTotalOriginal);
}
else
{
detailCart.OrderHeader.OrderTotal = detailCart.OrderHeader.OrderTotalOriginal;
}
detailCart.OrderHeader.CouponCodeDiscount = detailCart.OrderHeader.OrderTotalOriginal - detailCart.OrderHeader.OrderTotal;
_db.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32(SD.ssShoppingCartCount, 0);
await _db.SaveChangesAsync();
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + detailCart.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.BalanceTransactionId == null)
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
detailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
await _db.SaveChangesAsync();
// return RedirectToAction("Index", "Home");
return(RedirectToAction("Confirm", "Order", new { id = detailCart.OrderHeader.Id }));
}
public IActionResult OnPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
//Gets the list cart from the database
DetailsCart.ListCart = _unitOfWork.ShoppingCart.GetAll(c => c.ApplicationUserId == claim.Value).ToList();
//Sets the OrderHear
DetailsCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
DetailsCart.OrderHeader.OrderDate = DateTime.Now;
DetailsCart.OrderHeader.UserId = claim.Value;
DetailsCart.OrderHeader.Status = SD.PaymentStatusPending;
//Pickup time will be the pickup date + pickup time
DetailsCart.OrderHeader.PickupTime = Convert.ToDateTime(DetailsCart.OrderHeader.PickUpDate.ToShortDateString() + " " + DetailsCart.OrderHeader.PickupTime.ToShortTimeString());
//Create new OrderDetails to add in db
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
//Add the OrderHeader to db
_unitOfWork.OrderHeader.Add(DetailsCart.OrderHeader);
_unitOfWork.Save();
//Looping each item in the cart and adding it to order details to adding it to the database
foreach (var item in DetailsCart.ListCart)
{
item.MenuItem = _unitOfWork.MenuItem.GetFirstOrDefault(m => m.Id == item.MenuItemId);
OrderDetails orderDetails = new OrderDetails()
{
MenuItemId = item.MenuItemId,
Name = item.MenuItem.Name,
OrderId = DetailsCart.OrderHeader.Id,
Description = item.MenuItem.Description,
Price = item.MenuItem.Price,
Count = item.Count
};
DetailsCart.OrderHeader.OrderTotal += (orderDetails.Count * orderDetails.Price);
_unitOfWork.OrderDetails.Add(orderDetails);
}
DetailsCart.OrderHeader.OrderTotal = Convert.ToDouble($"{DetailsCart.OrderHeader.OrderTotal:.##}");
//Removes all the item from the shopping cart in the database through the remove range from repository
_unitOfWork.ShoppingCart.RemoveRange(DetailsCart.ListCart);
//Clear the session context so the user sees 0 items
HttpContext.Session.SetInt32(SD.ShoppingCart, 0);
//Do this here for efficiency
_unitOfWork.Save();
//Setting the payment for stripe
if (stripeToken != null)
{
//Charging a card for stripe
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(DetailsCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order Id: " + DetailsCart.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
DetailsCart.OrderHeader.TransactionId = charge.Id;
//checking how the payment went
if (charge.Status.ToLower() == "succeeded")
{
//email
DetailsCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
DetailsCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
DetailsCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
}
else
{
DetailsCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
_unitOfWork.Save();
return(RedirectToPage("/Customer/Cart/OrderConfirmation", new { id = DetailsCart.OrderHeader.Id }));
}
public async Task <IActionResult> Processing(string stripeToken, string stripeEmail, int amount, Enums.MembershipDuration membershipDuration)
{
ApplicationUser user = await userManager.FindByEmailAsync(User.Identity.Name);
// Checking if user has membership.
Claim claim = (await userManager.GetClaimsAsync(user)).Where(c => c.Type == "MembershipExpiry")
.OrderByDescending(c => c.Value)
.FirstOrDefault();
// If the user was previously granted membership, then do not issue a new one if the membership is still valid.
if (claim != null && Convert.ToDateTime(claim.Value) > DateTime.Today)
{
return(RedirectToAction("AlreadyAMember", "Error", routeValues: new { expiry = Convert.ToDateTime(claim.Value) }));
}
// This object contains information about the charge we will create.
ChargeCreateOptions options = new ChargeCreateOptions
{
Amount = amount,
Currency = "GBP",
Description = Enums.GetDisplayName(membershipDuration) + " membership",
Source = stripeToken,
ReceiptEmail = stripeEmail // This sends email receipt to the customer based on the entered email.
//// Metadata can be used to store more non-sensitive information for our own reference.
//// Stripe does not use this information.
//Metadata = new Dictionary<String, String>{ { "OrderId", "..." } }
};
// This creates the charge in which we pass in the information. The status of the charge will be pending until
// Stripe processes it and returns a status of either succeeded of failed.
ChargeService service = new ChargeService();
// The charge request is made here. It connects to Stripe servers and processes the transaction.
Charge charge = service.Create(options);
// Checking the status of the charge. Succeeded or failed or Pending.
try
{
if (charge.Status == "succeeded")
{
// Create new membership for the user.
DateTime expiry = Expiry.GetExpiryDate(membershipDuration);
IdentityResult result = await userManager.AddClaimAsync(user, new Claim("MembershipExpiry", expiry.ToShortDateString()));
ViewBag.FirstName = user.FirstName;
ViewBag.LastName = user.LastName;
ViewBag.ExpiryDate = expiry.ToShortDateString();
return(View(nameof(Success)));
}
if (charge.Status == "failed")
{
return(View(nameof(Fail)));
}
}
catch (Exception)
{
return(RedirectToAction("PaymentError", "Error"));
}
return(View());
}
public IActionResult SummaryPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
ShoppingCartVM.OrderHeader.ApplicationUser = _unitOfWork.ApplicationUser
.GetFirstOrDefault(c => c.Id == claim.Value);
ShoppingCartVM.ListCart = _unitOfWork.ShoppingCart
.GetAll(c => c.ApplicationUserId == claim.Value,
includeProperties: "Product").ToList();
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusPending;
ShoppingCartVM.OrderHeader.ApplicationUserId = claim.Value;
ShoppingCartVM.OrderHeader.OrderDate = DateTime.Now;
_unitOfWork.OrderHeader.Add(ShoppingCartVM.OrderHeader);
_unitOfWork.Save();
ShoppingCartVM.OrderHeader.OrderTotalOriginal = 0;
foreach (var item in ShoppingCartVM.ListCart)
{
item.Price = item.Product.Price;
OrderDetails orderDetails = new OrderDetails()
{
ProductId = item.ProductId,
OrderId = ShoppingCartVM.OrderHeader.Id,
Price = item.Price,
Count = item.Count
};
ShoppingCartVM.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
_unitOfWork.OrderDetails.Add(orderDetails);
}
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
ShoppingCartVM.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = _unitOfWork.Coupon.GetFirstOrDefault(c => c.Name.ToLower() == ShoppingCartVM.OrderHeader.CouponCode.ToLower());
ShoppingCartVM.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, ShoppingCartVM.OrderHeader.OrderTotalOriginal);
}
else
{
ShoppingCartVM.OrderHeader.OrderTotal = ShoppingCartVM.OrderHeader.OrderTotalOriginal;
}
ShoppingCartVM.OrderHeader.CouponCodeDiscount = ShoppingCartVM.OrderHeader.OrderTotalOriginal - ShoppingCartVM.OrderHeader.OrderTotal;
_unitOfWork.ShoppingCart.RemoveRange(ShoppingCartVM.ListCart);
_unitOfWork.Save();
HttpContext.Session.SetInt32(SD.ssShoppingCart, 0);
//process the payment
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(ShoppingCartVM.OrderHeader.OrderTotal * 100),
Currency = "sar",
Description = "Order ID : " + ShoppingCartVM.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.Id == null)
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
ShoppingCartVM.OrderHeader.TransactionId = charge.Id;
}
if (charge.Status.ToLower() == "succeeded")
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
ShoppingCartVM.OrderHeader.PaymentDate = DateTime.Now;
}
_unitOfWork.Save();
return(RedirectToAction("OrderConfirmation", "Cart", new { id = ShoppingCartVM.OrderHeader.Id }));
}
public IActionResult OnPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
detailCart.listCart = _unitOfWork.ShoppingCart.GetAll(c => c.ApplicationUserId == claim.Value).ToList();
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = SD.PaymentStatusPending;
detailCart.OrderHeader.PickUpTime = Convert.ToDateTime(detailCart.OrderHeader.PickUpDate.ToShortDateString() + " " + detailCart.OrderHeader.PickUpTime.ToShortTimeString());
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
_unitOfWork.OrderHeader.Add(detailCart.OrderHeader);
_unitOfWork.Save();
foreach (var item in detailCart.listCart)
{
item.MenuItem = _unitOfWork.MenuItem.GetFirstOrDefault(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 = item.MenuItem.Price,
Count = item.Count
};
detailCart.OrderHeader.OrderTotal += (orderDetails.Count * orderDetails.Price);
_unitOfWork.OrderDetails.Add(orderDetails);
}
detailCart.OrderHeader.OrderTotal = Convert.ToDouble(String.Format("{0:.##}", detailCart.OrderHeader.OrderTotal));
_unitOfWork.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32(SD.ShoppingCart, 0);
_unitOfWork.Save();
if (stripeToken != null)
{
var options = new ChargeCreateOptions
{
//Amount is in cents
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + detailCart.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
detailCart.OrderHeader.TransactionId = charge.Id;
if (charge.Status.ToLower() == "succeeded")
{
//email
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
_unitOfWork.Save();
return(RedirectToPage("/Customer/Cart/OrderConfirmation", new { id = detailCart.OrderHeader.Id }));
}
public bool Pay(
string CardNo,
int ExpiredYear, int ExpiredMonth,
string CVV,
decimal amount, string currency,
string receiptEmail = "", string description = "")
{
try
{
TokenCreateOptions stripeCard = new TokenCreateOptions
{
Card = new TokenCardOptions
{
Number = CardNo,
ExpMonth = Convert.ToInt64(ExpiredMonth),
ExpYear = Convert.ToInt64(ExpiredYear),
Cvc = CVV,
},
};
TokenService service = new TokenService();
Token newToken = service.Create(stripeCard);
var cardOption = new SourceCreateOptions
{
Type = SourceType.Card,
Currency = currency,
Token = newToken.Id
};
var sourceService = new SourceService();
Source source = sourceService.Create(cardOption);
/*
* CustomerCreateOptions customerInfo = new CustomerCreateOptions
* {
* Name = "SP Tutorial",
* Email = stripeEmail,
* Description = "Paying 10 Rs",
* Address = new AddressOptions {
* City = "Kolkata",
* Country = "India",
* Line1 = "Sample Address",
* Line2 = "Sample Address 2",
* PostalCode = "700030",
* State = "WB"
* }
* };
*
* //var customerService = new CustomerService();
* //var customer = customerService.Create(customerInfo);
*/
var chargeoption = new ChargeCreateOptions
{
Amount = Convert.ToInt32(amount * 100),
Currency = currency,
Description = description,
ReceiptEmail = receiptEmail,
Source = source.Id
};
var chargeService = new ChargeService();
Charge charge = chargeService.Create(chargeoption);
if (charge.Status == "succeeded")
{
return(true);
}
else
{
return(false);
}
}
catch (Exception e)
{
Console.WriteLine(e);
return(false);
}
}
public async Task <IActionResult> SummaryPOST(string stripeToken)
{
/*PROCESS FLOW OF THE STRIPE TOKEN
* When the user enters the credit card details and clicks the submit button,
* All the details are posted on the stripe server directly and are not saved anyhere on our server,
* Using the card numbers and details, stripe generates a token and sends the token to the post action method in the controller,
* We will use the token in the controller and pass it to make the actual charge
*/
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
detailCart.ListCart = await _db.ShoppingBag.Where(c => c.ApplicationUserId == claim.Value).ToListAsync(); //retrieving all of the shopping cart
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending; //because we'll be calculating that when we need userid of the user that is logged in, to retrieve all the items in the shopcart the user has
detailCart.OrderHeader.OrderDate = DateTime.Now; //because we'll be calculating that when we need userid of the user that is logged in, to retrieve all the items in the shopcart the user has
detailCart.OrderHeader.UserId = claim.Value; //because we'll be calculating that when we need userid of the user that is logged in, to retrieve all the items in the shopcart the user has
detailCart.OrderHeader.Status = SD.PaymentStatusPending; //because we'll be calculating that when we need userid of the user that is logged in, to retrieve all the items in the shopcart the user has
detailCart.OrderHeader.PickUpTime = Convert.ToDateTime(detailCart.OrderHeader.PickUpDate.ToShortDateString() + " " + detailCart.OrderHeader.PickUpTime.ToShortTimeString()); //because we'll be calculating that when we need userid of the user that is logged in, to retrieve all the items in the shopcart the user has
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
_db.OrderHeader.Add(detailCart.OrderHeader);
await _db.SaveChangesAsync();
var details = detailCart.OrderHeader.OrderTotalOriginal;
foreach (var item in detailCart.ListCart)//Calculate the order total so far
{
item.MenuItem = await _db.MenuItem.FirstOrDefaultAsync(m => m.Id == item.MenuItemId);
//Creating order details
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = detailCart.OrderHeader.Id,
Description = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
details = orderDetails.Count * orderDetails.Price;
_db.OrderDetails.Add(orderDetails);
await _db.SaveChangesAsync();
}
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
detailCart.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = await _db.Coupon.Where(c => c.Name.ToLower() == detailCart.OrderHeader.CouponCode.ToLower()).FirstOrDefaultAsync();
detailCart.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, detailCart.OrderHeader.OrderTotalOriginal);
}
else
{
detailCart.OrderHeader.OrderTotal = details;
}
detailCart.OrderHeader.CouponCodeDiscount = details - detailCart.OrderHeader.OrderTotal;
_db.ShoppingBag.RemoveRange(detailCart.ListCart);
HttpContext.Session.SetInt32(SD.ssShoppingCartCount, 0);
await _db.SaveChangesAsync();
//making the call (transaction) to stripe for getting our payment
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + detailCart.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);//This will do the actual transaction
//check if there is a transaction ID
if (charge.BalanceTransactionId == null)
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
detailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
await _db.SaveChangesAsync();
//return RedirectToAction("Index", "Home");
return(RedirectToAction("Confirm", "Order", new { id = detailCart.OrderHeader.Id }));//with a confirm action and a order header id
}
public async Task <IActionResult> SummeryPost(string stripeToken)
{
//Saving OrderHeader To database
var claimsIdentity = (ClaimsIdentity)this.User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier).Value;
DetailsCartVM.ShoppingCartList = await _db.ShoppingCart.Where(u => u.ApplicationUserId == claim).ToListAsync();
DetailsCartVM.OrderHeader.PaymentStatus = SD.StatusPending;
DetailsCartVM.OrderHeader.Status = SD.StatusPending;
DetailsCartVM.OrderHeader.ApplicationUserId = claim;
DetailsCartVM.OrderHeader.OrderDate = DateTime.Now;
DetailsCartVM.OrderHeader.PickUpTime = Convert.ToDateTime(DetailsCartVM.OrderHeader.PickUpDate.ToShortDateString() + " " + DetailsCartVM.OrderHeader.PickUpTime.ToShortTimeString());
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
_db.OrderHeaders.Add(DetailsCartVM.OrderHeader);
await _db.SaveChangesAsync();
DetailsCartVM.OrderHeader.OrderTotalOriginal = 0;
foreach (var item in DetailsCartVM.ShoppingCartList)
{
item.MenuItem = await _db.MenuItems.FirstOrDefaultAsync(u => u.MenuItemId == item.MenuItemId);
OrderDetails orderDetails = new OrderDetails
{
OrderId = DetailsCartVM.OrderHeader.OrderHeaderId,
MenuItemId = item.MenuItemId,
Count = item.Count,
ItemName = item.MenuItem.MenuItemName,
Price = item.MenuItem.Price
};
DetailsCartVM.OrderHeader.OrderTotalOriginal += item.Count * item.MenuItem.Price;
_db.OrderDetails.Add(orderDetails);
}
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
DetailsCartVM.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var coupon = _db.Coupons.FirstOrDefault(u => u.CouponName.ToLower() == DetailsCartVM.OrderHeader.CouponCode.ToLower());
DetailsCartVM.OrderHeader.OrderTotal = SD.DiscountedPrice(coupon, DetailsCartVM.OrderHeader.OrderTotalOriginal);
}
else
{
DetailsCartVM.OrderHeader.OrderTotal = DetailsCartVM.OrderHeader.OrderTotalOriginal;
}
DetailsCartVM.OrderHeader.CouponCodeDiscount = DetailsCartVM.OrderHeader.OrderTotalOriginal - DetailsCartVM.OrderHeader.OrderTotal;
_db.ShoppingCart.RemoveRange(DetailsCartVM.ShoppingCartList);
HttpContext.Session.SetInt32(SD.ssShoppingCartCount, 0);
await _db.SaveChangesAsync();
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32((DetailsCartVM.OrderHeader.OrderTotal / 80) * 100),
Currency = "usd",
Description = "Order Id : " + DetailsCartVM.OrderHeader.OrderHeaderId,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.Status.ToLower() == "succeeded")
{
DetailsCartVM.OrderHeader.TransactionId = charge.BalanceTransactionId;
await _emailSender.SendEmailAsync(_db.Users.Where(u => u.Id == claim).FirstOrDefault().Email,
"ForYou payment completed OrderId: " + DetailsCartVM.OrderHeader.OrderHeaderId.ToString(),
"You have paid " + DetailsCartVM.OrderHeader.OrderTotal.ToString() + " for your Order<br /> <strong class =\"text-info\">THANK YOU!!</strong>");
DetailsCartVM.OrderHeader.PaymentStatus = SD.StatusApproved;
DetailsCartVM.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
await _emailSender.SendEmailAsync(_db.Users.Where(u => u.Id == claim).FirstOrDefault().Email,
"ForYou payment completed OrderId: " + DetailsCartVM.OrderHeader.OrderHeaderId.ToString(),
"Your payment request failed anyway. Please contuct us for more information.<br /> <strong class =\"text-info\">THANK YOU!!</strong>");
DetailsCartVM.OrderHeader.PaymentStatus = SD.StatusRejected;
}
await _db.SaveChangesAsync();
//return RedirectToAction("Index", "Cart");
return(RedirectToAction("Confirm", "Order", new { id = DetailsCartVM.OrderHeader.OrderHeaderId }));
}
public async Task <IActionResult> SummaryPost(string stripeToken)
{
//---User id of logged user
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
//---Modify detail cart
//---Retrieve shopping cart
detailCart.listCart = await _db.ShoppingCart.Where(c => c.ApplicationUserId == claim.Value).ToListAsync();
//
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = SD.PaymentStatusPending;
detailCart.OrderHeader.PickupTime = Convert.ToDateTime(detailCart.OrderHeader.PickupDate.ToShortDateString() + " " + detailCart.OrderHeader.PickupTime.ToShortTimeString());
//---List of order details
List <OrderDetails> orderDetatilsList = new List <OrderDetails>();
_db.OrderHeader.Add(detailCart.OrderHeader);
//--Order header created in DB
await _db.SaveChangesAsync();
detailCart.OrderHeader.OrderTotalOriginal = 0;
foreach (var item in detailCart.listCart)
{
item.MenuItem = await _db.MenuItem.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 = item.MenuItem.Price,
Count = item.Count
};
//--For each item, calculate and add to total
detailCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
_db.OrderDetails.Add(orderDetails);
}
//---Use of coupon code and update the price
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
detailCart.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = await _db.Coupon.Where(c => c.Name.ToLower() == detailCart.OrderHeader.CouponCode.ToLower()).FirstOrDefaultAsync();
//---Coupon Applied, updating order total
detailCart.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, detailCart.OrderHeader.OrderTotalOriginal);
}
else
{
detailCart.OrderHeader.OrderTotal = detailCart.OrderHeader.OrderTotalOriginal;
}
detailCart.OrderHeader.CouponCodeDiscount = detailCart.OrderHeader.OrderTotalOriginal - detailCart.OrderHeader.OrderTotal;
//---Remove from session and shopping cart
await _db.SaveChangesAsync();
_db.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32(SD.ssShoppingCartCount, 0);
//---Saving everything
await _db.SaveChangesAsync();
//---Stripe funcionality
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID: " + detailCart.OrderHeader.Id,
SourceId = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
//---Check if there is a transaction id
if (charge.BalanceTransactionId == null)
{
//---There was a problem, report
detailCart.OrderHeader.Status = SD.PaymentStatusRejected;
}
else
{
detailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
//Payment approved!
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
//---Not approved
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
//---Finally, save changes
await _db.SaveChangesAsync();
//---For testing purposes
//return RedirectToAction("Index", "Home");
return(RedirectToAction("Confirm", "Order", new { id = detailCart.OrderHeader.Id }));
}
private void Button1_Click(object sender, EventArgs e)
{
try
{
/*
* Using Stripe's library to make request
* Everything below is from the Official Documentation
* From https://stripe.com/docs/api
*
*/
//Set To public key so we can create a Card Card Object
StripeConfiguration.ApiKey = MainForm.PubKey;
//Getting Card & Price Information // No Error Checks added so it can crash the program
int Month = Int32.Parse(MonthExpiry.Text);
int Year = Int32.Parse(YearExpiry.Text);
int PriceToCharge = (Int32.Parse(ChargeAmmount.Text)) * 100;
string CardNo = CardNoBox.Text;
string CVCText = SecCode.Text;
string UserEmail = EmailBox.Text;
string DescriptionText = DescBox.Text;
//Generating MetaData
Dictionary <String, String> MetadataToAdd = new Dictionary <String, String>()
{
{ "ItemID", ItemIDBox.Text },
{ "ItemName", ItemNameBox.Text },
{ "Country", CountryBox.Text }
};
//Creating A Token to "Build" the card.
var TokenOptions = new TokenCreateOptions
{
Card = new CreditCardOptions //Card Object
{
Number = CardNo,
ExpYear = Year,
ExpMonth = Month,
Cvc = CVCText
}
};
//Creating a Token and attaching Card Object
var Tokenservice = new TokenService();
Token stripeToken = Tokenservice.Create(TokenOptions);
//Set To Private key to tell API that we are Charging.
StripeConfiguration.ApiKey = MainForm.SecretKey;
//Ive Tried to add as much Paramters into the ChargeOptions as incase you find something useful. The Only Things you Require is Amount, Currency and Source.
var ChargeOptions = new ChargeCreateOptions
{
Amount = PriceToCharge,
Currency = "gbp",
ReceiptEmail = UserEmail,
Description = DescriptionText,
Metadata = MetadataToAdd,
Source = "tok_mastercard" // obtained with Stripe.js
};
//Creating a Service To Charge the Card
var ChargeService = new ChargeService();
Charge charge = ChargeService.Create(ChargeOptions);
//No Error
MessageBox.Show("Successfully Charged Card");
}
catch (StripeException ex)
{
//Switch Statement is from API Documentation
switch (ex.StripeError.ErrorType)
{
case "card_error":
MessageBox.Show("Code: " + ex.StripeError.Code);
MessageBox.Show("Message: " + ex.StripeError.Message);
break;
case "api_connection_error":
break;
case "api_error":
break;
case "authentication_error":
break;
case "invalid_request_error":
break;
case "rate_limit_error":
break;
case "validation_error":
break;
default:
// Unknown Error Type
break;
}
}
}
private void Button1_Click_1(object sender, EventArgs e)
{
//This is the same code above only difference is Source i could add in a check above to see if CustomerID is empty but i think its easier to help people understand the difference.
try
{
/*
* Using Stripe's library to make request
* Everything below is from the Official Documentation
* From https://stripe.com/docs/api
*
*/
//Set To public key so we can create a Card Card Object
StripeConfiguration.ApiKey = MainForm.PubKey;
//No Error Check Added so must be added in
//Getting User Information
int PriceToCharge = (Int32.Parse(ChargeAmmount.Text)) * 100;
string DescriptionText = DescBox.Text;
string CustomerID = CustomerIDBox.Text;
//Generating MetaData
Dictionary <String, String> MetadataToAdd = new Dictionary <String, String>()
{
{ "ItemID", ItemIDBox.Text },
{ "ItemName", ItemNameBox.Text },
{ "Country", CountryBox.Text }
};
//Set To Private key to tell API that we are Charging.
StripeConfiguration.ApiKey = MainForm.SecretKey;
//Ive Tried to add as much Paramters into the ChargeOptions as incase you find something useful. The Only Things you Require is Amount, Currency and Source.
var ChargeOptions = new ChargeCreateOptions
{
Amount = PriceToCharge,
Currency = "gbp",
Description = DescriptionText,
Metadata = MetadataToAdd,
CustomerId = CustomerID,
//Source = "tok_mastercard" //Not Putting in a source defaults to customers default payment method
};
//Creating a Service To Charge the Card
var ChargeService = new ChargeService();
Charge charge = ChargeService.Create(ChargeOptions);
//No Error
MessageBox.Show("Successfully Charged Customer");
}
catch (StripeException ex)
{
//Switch Statement is from API Documentation
switch (ex.StripeError.ErrorType)
{
case "card_error":
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
break;
case "api_connection_error":
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
break;
case "api_error":
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
break;
case "authentication_error":
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
break;
case "invalid_request_error":
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
break;
case "rate_limit_error":
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
break;
case "validation_error":
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
break;
default:
MessageBox.Show("Code: " + ex.StripeError.Code + " Message: " + ex.Message);
// Unknown Error Type
break;
}
}
}
public async Task <IActionResult> Create([FromBody] CreateOrderViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _db.Users.SingleAsync(x => x.UserName == HttpContext.User.Identity.Name);
var order = new Data.Entities.Order
{
DeliveryAddress = new Data.Entities.Address
{
FirstName = model.FirstName,
LastName = model.LastName,
Address1 = model.Address1,
Address2 = model.Address2,
TownCity = model.TownCity,
County = model.County,
Postcode = model.Postcode
},
Items = model.Items.Select(x => new Data.Entities.OrderItem
{
ProductId = x.ProductId,
ColourId = x.ColourId,
StorageId = x.StorageId,
Quantity = x.Quantity
}).ToList()
};
user.Orders.Add(order);
await _db.SaveChangesAsync();
var total = await _db.Orders
.Where(x => x.Id == order.Id)
.Select(x => Convert.ToInt32(x.Items.Sum(i => i.ProductVariant.Price * i.Quantity) * 100))
.SingleAsync();
var options = new ChargeCreateOptions
{
Amount = total,
Description = $"Order {order.Id} payment",
Currency = "GBP",
Source = model.StripeToken
};
var service = new ChargeService();
var charge = service.Create(options);
if (string.IsNullOrEmpty(charge.FailureCode))
{
order.PaymentStatus = PaymentStatus.Paid;
}
else
{
order.PaymentStatus = PaymentStatus.Declined;
}
await _db.SaveChangesAsync();
return(Ok(new CreateOrderResponseViewModel(order.Id, order.PaymentStatus)));
}
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 }));
}
public async Task <IActionResult> OnPostAsync([FromForm] string stripeToken)
{
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userManager.GetUserAsync(User);
UserEmail = user.Email;
StripeCustomerId = user.CustomerIdentifier;
var nullCustomerId = string.IsNullOrEmpty(StripeCustomerId);
var planId = Input.PlanId;
var planAmount = GetPlanPrice(planId);
var customerService = new CustomerService();
Customer customerLookup = new Customer();
if (!nullCustomerId)
{
customerLookup = customerService.Get(StripeCustomerId);
}
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
//Create new customer if doesnt exist
if (nullCustomerId || customerLookup.Deleted == true)
{
var customers = new CustomerService();
var customer = customers.Create(new CustomerCreateOptions
{
Email = UserEmail,
Plan = planId,
Description = UserEmail + " " + "[" + user.Id + "]"
});
user.CustomerIdentifier = customer.Id;
StripeCustomerId = user.CustomerIdentifier;
}
else
{
var subcriptionService = new SubscriptionService();
var subscriptionItems = new List <SubscriptionItemOptions>
{
new SubscriptionItemOptions
{
Plan = planId
}
};
var stripeSubscription = subcriptionService.Create(new SubscriptionCreateOptions
{
Customer = StripeCustomerId,
Items = subscriptionItems
});
}
Charge charge = new Charge();
if (planAmount > 0)
{
var chargeOptions = new ChargeCreateOptions
{
Amount = planAmount,
Currency = "usd",
Description = "RazorStripe for" + " " + UserEmail,
Customer = StripeCustomerId,
};
var chargeService = new ChargeService();
charge = chargeService.Create(chargeOptions);
}
await _db.SaveChangesAsync();
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Your payment: " + charge.Status;
return(RedirectToPage());
}
public async Task <IActionResult> Charge(string stripeEmail, string stripeToken)
{
var stripeProvider = await _paymentProviderRepository.Query().FirstOrDefaultAsync(x => x.Id == PaymentProviderHelper.StripeProviderId);
var stripeSetting = JsonConvert.DeserializeObject <StripeConfigForm>(stripeProvider.AdditionalSettings);
var stripeChargeService = new ChargeService(stripeSetting.PrivateKey);
var currentUser = await _workContext.GetCurrentUser();
var cart = await _cartService.GetActiveCart(currentUser.Id);
if (cart == null)
{
return(NotFound());
}
var orderCreationResult = await _orderService.CreateOrder(cart.Id, "Stripe", 0, OrderStatus.PendingPayment);
if (!orderCreationResult.Success)
{
TempData["Error"] = orderCreationResult.Error;
return(Redirect("~/checkout/payment"));
}
var order = orderCreationResult.Value;
var zeroDecimalOrderAmount = order.OrderTotal;
if (!CurrencyHelper.IsZeroDecimalCurrencies(_currencyService.CurrencyCulture))
{
zeroDecimalOrderAmount = zeroDecimalOrderAmount * 100;
}
var regionInfo = new RegionInfo(System.Threading.Thread.CurrentThread.CurrentUICulture.LCID);
var payment = new Payment()
{
OrderId = order.Id,
Amount = order.OrderTotal,
PaymentMethod = "Stripe",
CreatedOn = DateTimeOffset.UtcNow
};
try
{
var charge = stripeChargeService.Create(new ChargeCreateOptions
{
Amount = (int)zeroDecimalOrderAmount,
Description = "Sample Charge",
Currency = regionInfo.ISOCurrencySymbol,
SourceId = stripeToken
});
payment.GatewayTransactionId = charge.Id;
payment.Status = PaymentStatus.Succeeded;
order.OrderStatus = OrderStatus.PaymentReceived;
_paymentRepository.Add(payment);
await _paymentRepository.SaveChangesAsync();
return(Redirect($"~/checkout/success?orderId={order.Id}"));
}
catch (StripeException ex)
{
payment.Status = PaymentStatus.Failed;
payment.FailureMessage = ex.StripeError.Message;
order.OrderStatus = OrderStatus.PaymentFailed;
_paymentRepository.Add(payment);
await _paymentRepository.SaveChangesAsync();
TempData["Error"] = ex.StripeError.Message;
return(Redirect($"~/checkout/error?orderId={order.Id}"));
}
}
public ResultAndMessage ChargeAccountToAccount(string BuyerCustId,
string VendorAcctId,
decimal purchaseAmount,
decimal smFee)
{
ResultAndMessage result = new ResultAndMessage();
var charge = new ChargeCreateOptions
{
// What is this property?
//----------------------------------------
//charge.OnBehalfOf = stripeAcctId;
//-----------------------------------
// When you create destination charges on the platform account,
// Stripe automatically:
// -Settles charges in the country of the specified account,
// thereby minimizing declines
// -Uses the connected account’s currency for settlement,
// often avoiding currency conversions
// -Uses the fee structure for the connected account’s country
// This same functionality is not automatically provided when creating
// separate charges and transfers, but you can replicate it using
// the on_behalf_of attribute when creating the charge.
// Setting on_behalf_of defines the business of record for the charge
// and funds will be settled using that account.
// For Custom Accounts, simplest route
// create the charge on platform’s account
// destination parm - connected account that receives funds.
Destination = new ChargeDestinationCreateOptions()
{
Account = VendorAcctId
},
// always set these properties
Amount = purchaseAmount.ToPennies(),
Currency = "usd",
// two-step payments: you can first authorize a charge
// on your customer’s card, then wait to settle (capture)
// it later. When a charge is authorized, the funds are guaranteed
// by the issuing bank and the amount held on the customer’s card
// for up to seven days. If the charge is not captured within this time,
// the authorization is canceled and funds released.
// To authorize a payment without capturing it, make a charge request
// that also includes the capture parameter with a value of false.
// This instructs Stripe to only authorize the amount
// on the customer’s card.
//charge.Capture = false;
// Here's second step if two-step is employed
//var chargeService = new StripeChargeService();
//charge = chargeService.Capture({ CHARGE_ID});
// set this if you want to
Description = "simple-market purchase",
//charge.SourceTokenOrExistingSourceId = BuyerAcctId;
// set this property if using a customer
// - this MUST be set if you are using an existing source!
Customer = BuyerCustId,
ApplicationFeeAmount = smFee.ToPennies()
};
//string secKey = _cntxt.smAdmin.Single(r => r.type == AdminRecType.secKey).strData;
//if (string.IsNullOrEmpty(secKey))
//{
// result.message = "failure to fetch stripe key.";
// return result;
//}
//StripeConfiguration.SetApiKey(secKey);
var chargeService = new ChargeService();
Charge stripeCharge = chargeService.Create(charge);
result.success = true;
return(result);
}
public async Task <IActionResult> ChargeWithStripeAsync()
{
// Set your secret key: remember to change this to your live secret key in production
// See your keys here: https://dashboard.stripe.com/account/apikeys
StripeConfiguration.SetApiKey(options.ApiKey);
var chargeCreateOptions = new ChargeCreateOptions
{
Amount = 999,
Currency = "usd",
SourceId = "tok_chargeDeclinedExpiredCard",
ReceiptEmail = "*****@*****.**",
Metadata = new Dictionary <string, string>()
{
{ "OrderId", "6735" }
},
};
var service = new ChargeService();
service.ExpandBalanceTransaction = true;
service.ExpandCustomer = true;
service.ExpandInvoice = true;
Charge charge;
//stripe api errors
try
{
// Use Stripe's library to make request
charge = service.Create(chargeCreateOptions);
}
catch (StripeException e)
{
switch (e.StripeError.ErrorType)
{
case "card_error":
Console.WriteLine("Code: " + e.StripeError.Code);
Console.WriteLine("Message: " + e.StripeError.Message);
break;
case "api_connection_error":
break;
case "api_error":
break;
case "authentication_error":
break;
case "invalid_request_error":
break;
case "rate_limit_error":
break;
case "validation_error":
break;
default:
// Unknown Error Type
break;
}
}
return(Ok());
}
public async Task <IActionResult> OnPostAsync()
{
// Pizza builder
if (!ModelState.IsValid)
{
return(Page());
}
pizzaOrder.IsComplete = false;
_context.PizzaOrders.Add(pizzaOrder);
await _context.SaveChangesAsync();
// Stripe create charge
var chargeOptions = new ChargeCreateOptions
{
Amount = pizzaOrder.Cost,
Currency = "usd",
Source = "tok_visa",
};
// Only assign shipping details to a charge object if delivery is selected
if (pizzaOrder.IsDelivery == true)
{
var shippingOptions = new ChargeShippingOptions
{
Name = shippingAddress.FirstName + " " + shippingAddress.LastName,
Address = new AddressOptions()
{
Line1 = shippingAddress.Line1,
City = shippingAddress.City,
State = shippingAddress.State,
PostalCode = shippingAddress.PostalCode.ToString()
}
};
chargeOptions.Shipping = shippingOptions;
}
var service = new ChargeService();
TempData["OrderSize"] = pizzaOrder.Size;
TempData["OrderQuantity"] = pizzaOrder.Quantity;
TempData["OrderToppings"] = pizzaOrder.Toppings;
// Divide by 100 for TempData to make the cost more viewable without bringing in any
// JavaScript to format for us on the page. We only need the cost to be without a decimal
// when communicating with Stripe
TempData["OrderCost"] = pizzaOrder.Cost / 100;
if (pizzaOrder.IsDelivery == true)
{
TempData["OrderRetrieval"] = "Your order will arrive in 30 minutes or less!";
}
else
{
TempData["OrderRetrieval"] = "Your order will be ready for pickup in 15 minutes";
}
Charge charge = service.Create(chargeOptions);
return(RedirectToPage("./OrderConfirmation"));
}
public IActionResult Checkout(UserDetails userDetails, Bookings bookings, string stripeEmail, string stripeToken)
{
int userId = Convert.ToInt32(TempData["uid"]);
ViewBag.bookmovie = TempData["total"];
//ViewBag.total = bookmovie.Sum(item => item.Movies.MoviePrice * item.Quantity);
UserDetails user = context.UserDetails.Where(u => u.UserDetailId == userId).SingleOrDefault();
//Bookings book = context.Bookings.Where(b => b.BookingId == bookingId).SingleOrDefault();
var customers = new CustomerService();
var charges = new ChargeService();
var customer = customers.Create(new CustomerCreateOptions
{
Email = stripeEmail,
SourceToken = stripeToken
});
var charge = charges.Create(new ChargeCreateOptions
{
Amount = 500,
Description = "Sample Charge",
Currency = "usd",
CustomerId = customer.Id
});
var bookmovie = SessionHelper.GetObjectFromJson <List <Item> >(HttpContext.Session, "bookmovie");
var showTiming = Request.Form["showTiming"].ToString();
var amount = (TempData["total"]);
var uid = (TempData["uid"]).ToString();
checkAudi(showTiming);
Bookings booking = new Bookings()
{
BookingAmount = Convert.ToInt32(amount),
BookingDate = DateTime.Now,
ShowTiming = showTiming,
AudiName = audiName,
UserDetailId = Convert.ToInt32(uid),
};
context.Bookings.Add(booking);
context.SaveChanges();
List <BookingDetails> BookingDetail = new List <BookingDetails>();
for (int i = 0; i < bookmovie.Count; i++)
{
BookingDetails bookingDetail = new BookingDetails()
{
BookingId = booking.BookingId,
MovieId = bookmovie[i].Movies.MovieId,
QtySeats = bookmovie[i].Quantity
};
context.BookingDetails.Add(bookingDetail);
}
BookingDetail.ForEach(n => context.BookingDetails.Add(n));
context.SaveChanges();
Payments payment = new Payments();
{
payment.UserDetailId = int.Parse(HttpContext.Session.GetString("uid"));
payment.BookingId = booking.BookingId;
payment.StripePaymentId = charge.PaymentMethodId;
payment.Amount = ViewBag.bookmovie;
payment.CreatedDate = DateTime.Now;
payment.Description = "VISA";
payment.Card = Convert.ToInt32(charge.PaymentMethodDetails.Card.Last4);
}
context.Payments.Add(payment);
context.SaveChanges();
TempData.Keep("uid");
TempData["bookingId"] = booking.BookingId;
return(RedirectToAction("Invoice", "BookMovie"));
}
public IActionResult SummaryPost(ShoppingCartVM shoppingCartVM, string stripeToken)
{
Claim claim = GetClaim();
shoppingCartVM.OrderHeader.ApplicationUser = unitOfWork.ApplicationUser
.GetFirstOrDefault(c => c.Id == claim.Value, includeProperties: "Company");
shoppingCartVM.ListCart = unitOfWork.ShoppingCart
.GetAll(c => c.ApplicationUserId == claim.Value, includeProperties: "Product");
shoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
shoppingCartVM.OrderHeader.OrderStatus = SD.StatusPending;
shoppingCartVM.OrderHeader.ApplicationUserId = claim.Value;
shoppingCartVM.OrderHeader.OrderDate = DateTime.Now;
unitOfWork.OrderHeader.Add(shoppingCartVM.OrderHeader);
unitOfWork.Save();
foreach (var item in shoppingCartVM.ListCart)
{
item.Price = SetPrice(item);
OrderDetails orderDetails = new OrderDetails()
{
ProductId = item.ProductId,
OrderId = shoppingCartVM.OrderHeader.Id,
Price = item.Price,
Count = item.Count
};
shoppingCartVM.OrderHeader.OrderTotal += orderDetails.Count * orderDetails.Price;
unitOfWork.OrderDetails.Add(orderDetails);
}
unitOfWork.ShoppingCart.RemoveRange(shoppingCartVM.ListCart);
// Save in one call to remove cart and add order details
unitOfWork.Save();
HttpContext.Session.SetInt32(SD.ShoppingCartSession, 0);
// Should only be null if the user ordering is an authorized company
if (stripeToken == null)
{
//order will be created for delayed payment for authroized company
shoppingCartVM.OrderHeader.PaymentDueDate = DateTime.Now.AddDays(30);
shoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusDelayedPayment;
shoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
}
else
{
//process the payment
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(shoppingCartVM.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + shoppingCartVM.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
// Makes charge on card
Charge charge = service.Create(options);
if (charge.Id == null)
{
shoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
shoppingCartVM.OrderHeader.TransactionId = charge.Id;
}
if (charge.Status.ToLower() == "succeeded")
{
shoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
shoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
shoppingCartVM.OrderHeader.PaymentDate = DateTime.Now;
}
}
unitOfWork.Save();
return(RedirectToAction("OrderConfirmation", "Cart", new { id = shoppingCartVM.OrderHeader.Id }));
}
public async Task <IActionResult> Create(Order frmOrder)
{
if (ModelState.IsValid)
{
var user = _identitySvc.Get(HttpContext.User);
Order order = frmOrder;
order.UserName = user.Email;
order.BuyerId = user.Email;
var options = new RequestOptions
{
ApiKey = _config["StripePrivateKey"]
};
var chargeOptions = new ChargeCreateOptions()
{
//required
Amount = (int)(order.OrderTotal * 100),
Currency = "usd",
Source = order.StripeToken,
//optional
Description = string.Format("Order Payment {0}", order.UserName),
ReceiptEmail = order.UserName,
};
var chargeService = new ChargeService();
Charge stripeCharge = null;
try
{
stripeCharge = chargeService.Create(chargeOptions, options);
_logger.LogDebug("Stripe charge object creation" + stripeCharge.StripeResponse.ToString());
}
catch (StripeException stripeException)
{
_logger.LogError("Stripe exception " + stripeException.Message);
ModelState.AddModelError(string.Empty, stripeException.Message);
return(View(frmOrder));
}
try
{
if (stripeCharge.Id != null)
{
//_logger.LogDebug("TransferID :" + stripeCharge.Id);
order.PaymentAuthCode = stripeCharge.Id;
//_logger.LogDebug("User {userName} started order processing", user.UserName);
int orderId = await _orderSvc.CreateOrder(order);
//_logger.LogDebug("User {userName} finished order processing of {orderId}.", order.UserName, order.OrderId);
// await _cartSvc.ClearCart(user);
return(RedirectToAction("Complete", new { id = orderId, userName = user.UserName }));
}
else
{
ViewData["message"] = "Payment cannot be processed, try again";
return(View(frmOrder));
}
}
catch (BrokenCircuitException)
{
ModelState.AddModelError("Error", "It was not possible to create a new order, please try later on. (Business Msg Due to Circuit-Breaker)");
return(View(frmOrder));
}
}
else
{
return(View(frmOrder));
}
}
public async Task <IActionResult> OnPostAsync(string stripeToken)
{
ShoppingCartVM.Order.PaymentStatus = SD.PaymentStatus.APPROVED;
ShoppingCartVM.Order.OrderStatus = SD.OrderStatus.APPROVED;
ShoppingCartVM.Order.OrderDate = DateTime.Now;
ShoppingCartVM.CartItems = await _cartService.GetAll(ShoppingCartVM.Order.UserId);
ShoppingCartVM.Order.OrderTotal = CalculateSum(ShoppingCartVM.CartItems);
if (ModelState.IsValid)
{
try
{
if (stripeToken != null)
{
Models.Order newOrder = await _orderService.Create(ShoppingCartVM);
if (newOrder == null)
{
throw new Exception("Order creation failed");
}
HttpContext.Session.SetInt32(SD.CART_SESSION_KEY, 0);
var chargeOptions = new ChargeCreateOptions
{
Amount = Convert.ToInt32(newOrder.OrderTotal * 100),
Currency = "MYR",
Description = $"E-Mall Order No. {newOrder.Id}",
Source = stripeToken
};
var chargeService = new ChargeService();
Charge charge = chargeService.Create(chargeOptions);
if (charge.Id == null)
{
newOrder.PaymentStatus = SD.PaymentStatus.REJECTED;
}
else
{
newOrder.TransactionId = charge.Id;
}
if (charge.Status.ToLower() == SD.StripeChargeStatus.SUCCEEDED)
{
newOrder.PaymentStatus = SD.PaymentStatus.APPROVED;
newOrder.OrderStatus = SD.OrderStatus.APPROVED;
newOrder.PaymentDate = DateTime.Now;
}
await _orderService.Update(newOrder);
SuccessMessage = "Thank you! Your order has been placed successfully!";
}
}
catch
{
ErrorMessage = "There is an error placing your order. Please try again later.";
}
}
else
{
ErrorMessage = "The information provided is not valid.";
}
return(RedirectToPage());
}
public IActionResult SummaryPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
ShoppingCartVM.OrderHeader.ApplicationUser = _unitOfWork.ApplicationUser
.GetFirstOrDefault(c => c.Id == claim.Value,
includeProperties: "Company");
ShoppingCartVM.ListCart = _unitOfWork.ShoppingCart
.GetAll(c => c.ApplicationUserId == claim.Value,
includeProperties: "Product");
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusPending;
ShoppingCartVM.OrderHeader.ApplicationUserId = claim.Value;
ShoppingCartVM.OrderHeader.OrderDate = DateTime.Now;
_unitOfWork.OrderHeader.Add(ShoppingCartVM.OrderHeader);
_unitOfWork.Save();
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
foreach (var item in ShoppingCartVM.ListCart)
{
item.Price = SD.GetPriceBasedOnQuantity(item.Count, item.Product.Price,
item.Product.Price50, item.Product.Price100);
OrderDetails orderDetails = new OrderDetails()
{
ProductId = item.ProductId,
OrderId = ShoppingCartVM.OrderHeader.Id,
Price = item.Price,
Count = item.Count
};
ShoppingCartVM.OrderHeader.OrderTotal += orderDetails.Count * orderDetails.Price;
_unitOfWork.OrderDetails.Add(orderDetails);
}
_unitOfWork.ShoppingCart.RemoveRange(ShoppingCartVM.ListCart);
_unitOfWork.Save();
HttpContext.Session.SetInt32(SD.ssShoppingCart, 0);
if (stripeToken == null)
{
//order will be created for delayed payment for authroized company
ShoppingCartVM.OrderHeader.PaymentDueDate = DateTime.Now.AddDays(30);
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusDelayedPayment;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
}
else
{
//process the payment
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(ShoppingCartVM.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID : " + ShoppingCartVM.OrderHeader.Id,
Source = stripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.BalanceTransactionId == null)
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
ShoppingCartVM.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
ShoppingCartVM.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
ShoppingCartVM.OrderHeader.OrderStatus = SD.StatusApproved;
ShoppingCartVM.OrderHeader.PaymentDate = DateTime.Now;
}
}
_unitOfWork.Save();
return(RedirectToAction("OrderConfirmation", "Cart", new { id = ShoppingCartVM.OrderHeader.Id }));
}
public async Task <IActionResult> SummaryPost(string stripeToken, OrderHeader orderHeader, OrderDetailsCart orderdetailsCart)
{
//-- sega dobaveno
//var detailCart = new Models.ViewModels.OrderDetailsCart()
//{
// OrderHeader = orderHeader
//};
//-- do tuk
//var detalCart = orderdetailsCart;
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
detailCart.listCart = await _db.ShoppingCart.Where(c => c.ApplicationUserId == claim.Value).ToListAsync();
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = SD.PaymentStatusPending;
List <OrderDetails> orderDetailsList = new List <OrderDetails>();
_db.OrderHeader.Add(detailCart.OrderHeader);
await _db.SaveChangesAsync();
foreach (var item in detailCart.listCart)
{
item.MenuItem = await _db.MenuItem.FirstOrDefaultAsync(m => m.Id == item.MenuItemId);
OrderDetails orderDetails = new OrderDetails
{
MenuItemId = item.MenuItemId,
OrderId = detailCart.OrderHeader.Id,
Desctiopion = item.MenuItem.Description,
Name = item.MenuItem.Name,
Price = item.MenuItem.Price,
Count = item.Count
};
detailCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderDetails.Price;
_db.OrderDetails.Add(orderDetails);
}
// detailCart.OrderHeader.OrderTotalOriginal = detailCart.OrderHeader.OrderTotal;
if (HttpContext.Session.GetString(SD.ssCouponCode) != null)
{
detailCart.OrderHeader.CouponCode = HttpContext.Session.GetString(SD.ssCouponCode);
var couponFromDb = await _db.Coupon.Where(c => c.Name.ToLower() == detailCart.OrderHeader.CouponCode.ToLower()).FirstOrDefaultAsync();
detailCart.OrderHeader.OrderTotal = SD.DiscountedPrice(couponFromDb, detailCart.OrderHeader.OrderTotalOriginal);
}
else
{
detailCart.OrderHeader.OrderTotal = detailCart.OrderHeader.OrderTotalOriginal;
}
detailCart.OrderHeader.CouponCodeDiscount = detailCart.OrderHeader.OrderTotalOriginal - detailCart.OrderHeader.OrderTotal;
_db.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32(SD.ssShopingCartCount, 0);
await _db.SaveChangesAsync();
//to execute the actual payment and charge the credit card
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(detailCart.OrderHeader.OrderTotal * 100),
Currency = "BGN",
Description = "Order ID: " + detailCart.OrderHeader.Id,
Source = stripeToken
};
//
var service = new ChargeService();
//to make the actual trasaction
Charge charge = service.Create(options);
//check the result
if (charge.BalanceTransactionId == null)
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
detailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "succeeded")
{
//send order confirmation Email to the customer
await _emailSender.SendEmailAsync(_db.Users.Where(u => u.Id == claim.Value).FirstOrDefault().Email,
"Lazy Dayze order " + detailCart.OrderHeader.Id.ToString() + " successfully accepted!",
"You order number " + detailCart.OrderHeader.Id.ToString() + " has been submitted successfully");
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
//
await _db.SaveChangesAsync();
return(RedirectToAction("Confirm", "Order", new { id = detailCart.OrderHeader.Id }));
// return RedirectToAction("Index", "Home");
}
public async Task <ActionResult> Payments(String stripeToken)
{
Abonnement abonnement = (Abonnement)Session["abonnement"];
if (abonnement == null || _me == null || _me.type != "client")
{
TempData["result_code"] = -1;
TempData["message"] = "Temps fourni pour abonnement expiré veillez réessayer.";
TempData.Keep();
return(RedirectToAction("Index", "Home"));
}
if (String.IsNullOrEmpty(stripeToken))
{
return(HttpNotFound());
}
StripeConfiguration.SetApiKey(STRIPE_API_KEY);
var stripeOptions = new ChargeCreateOptions
{
Amount = (long)Math.Ceiling(abonnement.montant.Value) * 100, // 1 dollar is equal to 100 cent.
Currency = "USD",
Description = "Charge for " + _me.email + " to abonnement " + abonnement.titre,
Source = stripeToken,
//Customer = customer.Id
};
var service = new ChargeService();
InsAbonne insAbonne = new InsAbonne();
insAbonne.Abo_id = abonnement.id;
insAbonne.Ins_id = _me.id;
insAbonne.libelle = "Abonnement " + abonnement.titre;
insAbonne.status = 1;
insAbonne.archived = 1;
insAbonne.etat = abonnement.nbrePost;
insAbonne.created = DateTime.Now;
insAbonne.dateDebut = DateTime.Now.ToString();
if (!needAbonnement() && DateTime.Parse(lastAsbonnement.dateFin) > DateTime.Now)
{
insAbonne.dateFin = DateTime.Parse(lastAsbonnement.dateFin).AddMonths(1).ToString();
insAbonne.etat += lastAsbonnement.etat;
lastAsbonnement.status = 0;
db.Entry(lastAsbonnement).State = EntityState.Modified;
}
else
{
insAbonne.dateFin = DateTime.Now.AddMonths(1).ToString();
}
db.InsAbonne.Add(insAbonne);
try
{
Charge charge = service.Create(stripeOptions);
var map = new Dictionary <String, String>();
map.Add("@ViewBag.titre", " Payment de l'abonnement " + abonnement.titre);
map.Add("@ViewBag.login", _me.login);
map.Add("@ViewBag.content", "Votre abonnement a bien été pris en compte. Bénéficiez du meilleur de nos service.");
string body = MsMail.BuldBodyTemplate("~/EmailTemplate/CustomEmail.cshtml", map);
MsMail mail = new MsMail();
if (this.lastAsbonnement != null)
{
lastAsbonnement.status = 0;
db.Entry(lastAsbonnement).State = EntityState.Modified;
}
db.SaveChanges();
//TODO retraviller le mail avec du HTML
await mail.Send(_me.email, "Abonnement", body);
}catch (StripeException e)
{
}
ViewBag.inscrire = _me;
ViewBag.insAbonne = insAbonne;
ViewBag.hasPaid = true;
return(View(abonnement));
}
public IActionResult OnPost(string StripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claims = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
OrderdetailsCart.CartList = _unitOfWork.ShoppingCartRepository.GetAll(c => c.ApplicationUserID == claims.Value).ToList();
OrderdetailsCart.OrderHeader.PaymentStatus = StaticDetails.PaymentPending;
OrderdetailsCart.OrderHeader.OrderDate = DateTime.Now;
OrderdetailsCart.OrderHeader.UserId = claims.Value;
OrderdetailsCart.OrderHeader.Status = StaticDetails.PaymentPending;
OrderdetailsCart.OrderHeader.PickUpTime = Convert.ToDateTime(OrderdetailsCart.OrderHeader.PickUpDate.ToShortDateString() + " " + OrderdetailsCart.OrderHeader.PickUpTime.ToShortTimeString());
List <OrderdetailsCart> details = new List <OrderdetailsCart>();
_unitOfWork.OrderHeaderRepository.Add(OrderdetailsCart.OrderHeader);
_unitOfWork.Save();
foreach (var item in OrderdetailsCart.CartList)
{
item.MenuItems = _unitOfWork.MenuItemsRepository.GetFirstOrDefault(m => m.Id == item.MenuItemID);
OrderDetails orderDetails = new OrderDetails()
{
MenuItemId = item.MenuItemID,
OrderId = OrderdetailsCart.OrderHeader.Id,
Descripiton = item.MenuItems.Description,
Name = item.MenuItems.Name,
Price = item.MenuItems.Price,
Count = item.Count
};
OrderdetailsCart.OrderHeader.OrderTotal += (orderDetails.Count * orderDetails.Price);
_unitOfWork.OrderDetailsRepository.Add(orderDetails);
}
OrderdetailsCart.OrderHeader.OrderTotal = Convert.ToDouble(String.Format("{0:.##}", OrderdetailsCart.OrderHeader.OrderTotal));
_unitOfWork.ShoppingCartRepository.RemoveRange(OrderdetailsCart.CartList);
HttpContext.Session.SetInt32(StaticDetails.ShoppingCart, 0);
_unitOfWork.Save();
if (StripeToken != null)
{
var options = new ChargeCreateOptions
{
Amount = Convert.ToInt32(OrderdetailsCart.OrderHeader.OrderTotal * 100),
Currency = "usd",
Description = "Order ID :" + OrderdetailsCart.OrderHeader.Id,
Source = StripeToken
};
var service = new ChargeService();
Charge charge = service.Create(options);
OrderdetailsCart.OrderHeader.TransactionId = charge.Id;
if (charge.Status.ToLower() == "Succeeded")
{
OrderdetailsCart.OrderHeader.PaymentStatus = StaticDetails.PaymentApproved;
OrderdetailsCart.OrderHeader.Status = StaticDetails.StatusSubmitted;
}
else
{
OrderdetailsCart.OrderHeader.PaymentStatus = StaticDetails.PaymentRejected;
}
}
else
{
OrderdetailsCart.OrderHeader.PaymentStatus = StaticDetails.PaymentRejected;
}
_unitOfWork.Save();
return(RedirectToPage("/Customer/Cart/OrderConfirmation", new { id = OrderdetailsCart.OrderHeader.Id }));
}
public void PayViaStripe()
{
StripeConfiguration.ApiKey = "sk_test_LJ2dJvulsi1f4rsGrqLHCKGC*****";
string cardno = cardNo.Text;
string expMonth = expireMonth.Text;
string expYear = expireYear.Text;
string cardCvv = cvv.Text;
// Step 1: create card option
CreditCardOptions stripeOption = new CreditCardOptions();
stripeOption.Number = cardno;
stripeOption.ExpYear = Convert.ToInt64(expYear);
stripeOption.ExpMonth = Convert.ToInt64(expMonth);
stripeOption.Cvc = cardCvv;
// step 2: Assign card to token object
TokenCreateOptions stripeCard = new TokenCreateOptions();
stripeCard.Card = stripeOption;
TokenService service = new TokenService();
Token newToken = service.Create(stripeCard);
// step 3: assign the token to the source
var option = new SourceCreateOptions
{
Type = SourceType.Card,
Currency = "inr",
Token = newToken.Id
};
var sourceService = new SourceService();
Source source = sourceService.Create(option);
// step 4: create customer
CustomerCreateOptions customer = new CustomerCreateOptions
{
Name = "SP Tutorial",
Email = "*****@*****.**",
Description = "Paying 10 Rs",
Address = new AddressOptions {
City = "Kolkata", Country = "India", Line1 = "Sample Address", Line2 = "Sample Address 2", PostalCode = "700030", State = "WB"
}
};
var customerService = new CustomerService();
var cust = customerService.Create(customer);
// step 5: charge option
var chargeoption = new ChargeCreateOptions
{
Amount = 45000,
Currency = "INR",
ReceiptEmail = "*****@*****.**",
Customer = cust.Id,
Source = source.Id
};
// step 6: charge the customer
var chargeService = new ChargeService();
Charge charge = chargeService.Create(chargeoption);
if (charge.Status == "succeeded")
{
// success
}
else
{
// failed
}
}
public async Task <IActionResult> CheckoutPost(string stripeToken)
{
var claimsIdentity = (ClaimsIdentity)User.Identity;
var claim = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier);
detailCart.listCart = await _db.ShoppingCart.Where(c => c.ApplicationUserId == claim.Value).ToListAsync();
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusPending;
detailCart.OrderHeader.OrderDate = DateTime.Now;
detailCart.OrderHeader.UserId = claim.Value;
detailCart.OrderHeader.Status = SD.PaymentStatusPending;
List <OrderDetail> orderDetails = new List <OrderDetail>();
_db.OrderHeader.Add(detailCart.OrderHeader);
await _db.SaveChangesAsync();
detailCart.OrderHeader.OrderTotalOriginal = 0;
foreach (var item in detailCart.listCart)
{
item.Productitem = await _db.ProductsModel.FirstOrDefaultAsync(m => m.Id == item.ProductId);
OrderDetail orderdetails = new OrderDetail
{
ProductItemId = item.ProductId,
OrderId = detailCart.OrderHeader.Id,
Description = item.Productitem.About,
Name = item.Productitem.Name,
Price = item.Productitem.Price,
Count = item.Count
};
detailCart.OrderHeader.OrderTotalOriginal += orderDetails.Count * orderdetails.Price;
_db.OrderDetail.Add(orderdetails);
}
_db.ShoppingCart.RemoveRange(detailCart.listCart);
HttpContext.Session.SetInt32("ssCartCount", 0);
await _db.SaveChangesAsync();
var options = new ChargeCreateOptions
{
Amount = 10000,
Currency = "usd",
Source = stripeToken,
Description = "Order Id : " + detailCart.OrderHeader.Id,
};
var service = new ChargeService();
Charge charge = service.Create(options);
if (charge.BalanceTransactionId == null)
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
else
{
detailCart.OrderHeader.TransactionId = charge.BalanceTransactionId;
}
if (charge.Status.ToLower() == "Succeeded")
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusApproved;
detailCart.OrderHeader.Status = SD.StatusSubmitted;
}
else
{
detailCart.OrderHeader.PaymentStatus = SD.PaymentStatusRejected;
}
await _db.SaveChangesAsync();
return(RedirectToAction("Confirm", "Order"));
}
