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")); }