public ActionResult Custom(CustomViewModel customViewModel)
        {
            customViewModel.PaymentFormHidden = false;
            var chargeOptions = new StripeChargeCreateOptions()
            {
                //required
                Amount = 3900,
                Currency = "usd",
                Source = new StripeSourceOptions() { TokenId = customViewModel.StripeToken },
                //optional
                Description = string.Format("JavaScript Framework Guide Ebook for {0}", customViewModel.StripeEmail),
                ReceiptEmail = customViewModel.StripeEmail
            };

            var chargeService = new StripeChargeService();

            try
            {
                StripeCharge stripeCharge = chargeService.Create(chargeOptions);

                //Validate charge
                chargeService.Capture(stripeCharge.Id);

                if (stripeCharge.Status == "succeeded")
                {
                    //creating the customer and add it to stripe
                    var newCustomer = new StripeCustomerService().Create(
                        new StripeCustomerCreateOptions
                        {
                            Email = customViewModel.StripeEmail
                        }
                        );
                    // CREATE NEW INVOICE
                    // var invoiceService = new StripeInvoiceService();
                    // StripeInvoice response = invoiceService.Create(newCustomer.Id); // optional StripeInvoiceCreateOptions
                    //var response = invoiceService.Upcoming(newCustomer.Id);
                    // stripeCharge.InvoiceId = response.Id;

                    //SEND THE CONFIRMATION
                    var emailService = new EmailService();
                    emailService.SendPaymentReceivedFromChargeEmail(stripeCharge);

                }
            }
            catch (StripeException stripeException)
            {
                Debug.WriteLine(stripeException.Message);
                ModelState.AddModelError(string.Empty, stripeException.Message);
                return View(customViewModel);
            }

            return RedirectToAction("Confirmation");
        }
Esempio n. 2
0
        public override ApiInfo CapturePayment( Order order, IDictionary<string, string> settings )
        {
            try {
            order.MustNotBeNull( "order" );
            settings.MustNotBeNull( "settings" );
            settings.MustContainKey( "mode", "settings" );
            settings.MustContainKey( settings[ "mode" ] + "_secret_key", "settings" );

            StripeChargeService chargeService = new StripeChargeService( settings[ settings[ "mode" ] + "_secret_key" ] );
            StripeCharge charge = chargeService.Capture( order.TransactionInformation.TransactionId, (int)order.TransactionInformation.AmountAuthorized.Value * 100 );

            return new ApiInfo( charge.Id, GetPaymentState( charge ) );
              } catch ( Exception exp ) {
            LoggingService.Instance.Log( exp, "Stripe(" + order.OrderNumber + ") - GetStatus" );
              }

              return null;
        }
        public async Task<ActionResult> OrderAction(int id, int status)
        {
            var order = await _orderService.FindAsync(id);

            if (order == null)
                return new HttpNotFoundResult();

            // Get the latest successful transaction
            var transactionQuery = await _orderTransactionService.Query(x => x.OrderID == id && string.IsNullOrEmpty(x.FailureCode)).SelectAsync();
            var transaction = transactionQuery.OrderByDescending(x => x.Created).FirstOrDefault();

            if (transaction == null)
            {
                var resultFailure = new { Success = "false", Message = "Transaction not found" };
                return Json(resultFailure, JsonRequestBehavior.AllowGet);
            }

            if (status == (int)Enum_OrderStatus.Cancelled)
            {
                // Update order
                order.Modified = DateTime.Now;
                order.Status = status;
                order.ObjectState = Repository.Pattern.Infrastructure.ObjectState.Modified;
                _orderService.Update(order);

            }
            else if (status == (int)Enum_OrderStatus.Confirmed)
            {
                // Update order
                order.Modified = DateTime.Now;
                order.Status = status;
                order.ObjectState = Repository.Pattern.Infrastructure.ObjectState.Modified;
                _orderService.Update(order);

                // Update Transaction
                transaction.IsCaptured = true;
                transaction.LastUpdated = DateTime.Now;
                _orderTransactionService.Update(transaction);

                // Capture payment
                var chargeService = new StripeChargeService(CacheHelper.GetSettingDictionary(Enum_SettingKey.StripeApiKey).Value);
                StripeCharge stripeCharge = chargeService.Capture(transaction.ChargeID);
            }

            await _unitOfWorkAsync.SaveChangesAsync();

            var result = new { Success = "true", Message = "" };
            return Json(result, JsonRequestBehavior.AllowGet);
        }
        public bool OrderAction(int id, int status, out string message)
        {
            message = string.Empty;

            var order = _orderService.Find(id);

            // Get the latest successful transaction
            var transactionQuery = _transactionService.Query(x => x.OrderID == id && string.IsNullOrEmpty(x.FailureCode)).Select();
            var transaction = transactionQuery.OrderByDescending(x => x.Created).FirstOrDefault();

            if (transaction == null)
            {
                message = "[[[Transaction not found]]]";
                return false;
            }

            if (status == (int)Enum_OrderStatus.Cancelled)
            {
                // Update order
                order.Modified = DateTime.Now;
                order.Status = status;
                order.ObjectState = Repository.Pattern.Infrastructure.ObjectState.Modified;
                _orderService.Update(order);

            }
            else if (status == (int)Enum_OrderStatus.Confirmed)
            {
                // Update order
                order.Modified = DateTime.Now;
                order.Status = status;
                order.ObjectState = Repository.Pattern.Infrastructure.ObjectState.Modified;
                _orderService.Update(order);

                // Update Transaction
                transaction.IsCaptured = true;
                transaction.LastUpdated = DateTime.Now;
                _transactionService.Update(transaction);

                // Capture payment
                var chargeService = new StripeChargeService(CacheHelper.GetSettingDictionary(StripePlugin.SettingStripeApiKey).Value);
                StripeCharge stripeCharge = chargeService.Capture(transaction.ChargeID);
            }

            _unitOfWorkAsync.SaveChanges();
            _unitOfWorkAsyncStripe.SaveChanges();

            return true;
        }