public override void ProcessCallback(Payment payment) { InitClient(payment); // BH: Normally, our payment processor would "ping" this endpoint. // However, we're going to do it from AJAX ourselves, thus negating the need for a Stripe webhook. var paymentIntentId = payment.PaymentProperties.First(p => p.Key == PaymentIntentKey).Value; // Just confirm the payment intent exists var paymentIntent = PaymentIntentService.Get(paymentIntentId); // Firstly: does the payment intent require manual confirmation? if (paymentIntent.ConfirmationMethod == "manual") { try { paymentIntent = PaymentIntentService.Confirm(paymentIntent.Id); } catch { throw new InvalidOperationException("Could not confirm payment intent"); } } if (paymentIntent.Status != StripeStatus.Succeeded) { throw new InvalidOperationException("Payment intent capture not successful"); } var transaction = paymentIntent.Charges.First(); if (transaction.Currency != payment.PurchaseOrder.BillingCurrency.ISOCode.ToLower()) { throw new InvalidOperationException($"The payment currency ({payment.PurchaseOrder.BillingCurrency.ISOCode.ToUpper()}) and the currency configured for the merchant account ({transaction.Currency.ToUpper()}) doesn't match. Make sure that the payment currency matches the currency selected in the merchant account."); } var paymentStatus = PaymentStatusCode.Declined; if (paymentIntent.Status == StripeStatus.Succeeded) { if (string.IsNullOrEmpty(transaction.Id)) { throw new ArgumentException(@"Charge ID must be present in the PaymentIntent object."); } payment.TransactionId = paymentIntent.Id; // This is used for paymentStatus = PaymentStatusCode.Authorized; } payment.PaymentStatus = PaymentStatus.Get((int)paymentStatus); ProcessPaymentRequest(new PaymentRequest(payment.PurchaseOrder, payment)); HttpContext.Current.Response.StatusCode = 200; }
public Session GetSessionBySessionId(string sessionId) { var res = sessions.Get(sessionId); res.PaymentIntent = paymentIntents.Get(res.PaymentIntentId); return(res); }
public dynamic confirmPayment(ConfirmPaymentInfo confirmPaymentInfo) { string stripeRedirectUrl = String.IsNullOrEmpty(confirmPaymentInfo.RedirectUrl)? GetEnvironmentConfigVar(StripeConfigKey, this.configuration.GetValue <string>(StripeConfigRedirectUrl)) + "/Home/ConfirmPayment":confirmPaymentInfo.RedirectUrl; var paymentIntentService = new PaymentIntentService(); PaymentIntent paymentIntent = null; try { if (confirmPaymentInfo.PaymentIntentId != null) { paymentIntent = paymentIntentService.Get(confirmPaymentInfo.PaymentIntentId); if (paymentIntent.Status == "requires_payment_method") { generatePaymentResponse(paymentIntent); } else { var confirmOptions = new PaymentIntentConfirmOptions { ReturnUrl = stripeRedirectUrl }; paymentIntent = paymentIntentService.Confirm( confirmPaymentInfo.PaymentIntentId, confirmOptions ); } } } catch (StripeException e) { return(new { error = e.StripeError.Message }); } return(generatePaymentResponse(paymentIntent)); }
private string ProcessWebhookRequest(Order order, HttpRequest request, IDictionary <string, string> settings) { var apiKey = settings[settings["mode"] + "_secret_key"]; var webhookSecret = settings[settings["mode"] + "_webhook_secret"]; ConfigureStripe(apiKey); var stripeEvent = GetWebhookStripeEvent(request, webhookSecret); if (stripeEvent.Type == "payment_intent.amount_capturable_updated") // Occurs when payments are not auto captured and funds are authorized { var paymentIntent = (PaymentIntent)stripeEvent.Data.Object.Instance; FinalizeOrUpdateOrder(order, paymentIntent); } else if (stripeEvent.Type.StartsWith("charge.")) { var charge = (Charge)stripeEvent.Data.Object.Instance; if (!string.IsNullOrWhiteSpace(charge.PaymentIntentId)) { var paymentIntentService = new PaymentIntentService(); var paymentIntentGetOptions = new PaymentIntentGetOptions { }; var paymentIntent = paymentIntentService.Get(charge.PaymentIntentId, paymentIntentGetOptions); FinalizeOrUpdateOrder(order, paymentIntent); } } return(null); }
public string GetClientSecret(string paymentIntentId) { var paymentIntent = _paymentIntentService.Get(paymentIntentId); var clientSecret = paymentIntent.ClientSecret; return(clientSecret); }
public ActionResult HandleCardPaymentComplete(StripePayment model) { StripeConfiguration.ApiKey = ConfigurationManager.AppSettings["Cashier:Stripe:Secret"]; var paymentIntent = PaymentService.GetPaymentIntentByTransactionRef(model.TransactionReference); var service = new PaymentIntentService(); ExStripe.PaymentIntent stripePI = null; if (paymentIntent.MotoMode == true) { //if it's a moto payment, we need to create the payment intent from var servicePM = new PaymentMethodService(); var paymentMethod = servicePM.Get(model.StripePaymentIntentId); var piCreate = new PaymentIntentCreateOptions { Amount = (long)paymentIntent.Amount * 100, Currency = paymentIntent.Currency, Description = paymentIntent.Description, Confirm = true, PaymentMethod = model.StripePaymentIntentId, PaymentMethodOptions = new PaymentIntentPaymentMethodOptionsOptions { Card = new PaymentIntentPaymentMethodOptionsCardOptions { Moto = true } } }; piCreate.Metadata = new Dictionary <string, string> { { "TransactionReference", paymentIntent.TransactionReference } }; try { stripePI = service.Create(piCreate); } catch (StripeException ex) { stripePI = ex.StripeError.PaymentIntent; } model.StripePaymentIntentId = stripePI.Id; } stripePI = stripePI ?? service.Get(model.StripePaymentIntentId); if (stripePI.Status == "succeeded" && stripePI.Metadata["TransactionReference"] == model.TransactionReference) { PaymentService.UpdatePaymentStatus(model.TransactionReference, model.StripePaymentIntentId, PaymentStatus.Succeeded); return(Redirect(paymentIntent.ConfirmationPageUrl)); } PaymentService.UpdatePaymentStatus(model.TransactionReference, model.StripePaymentIntentId, PaymentStatus.Failed); return(Redirect(paymentIntent.FailurePageUrl)); }
private PaymentIntent GetPaymentIntent(string paymentIntentId) { StripeConfiguration.ApiKey = ApiSecretKey; var service = new PaymentIntentService(); PaymentIntent intent = service.Get(paymentIntentId); return(intent); }
public ActionResult Confirm(PaymentIntentConfirmRequest request) { var service = new PaymentIntentService(); var paymentIntent = service.Get(request.PaymentIntentId); var narudzba = db.Rezervacija .Where(x => x.RezervacijaId == request.RezervacijaId) .Include(x => x.RezervacijaIznajmljenaBicikla) .Include(x => x.RezervacijaServis) .FirstOrDefault(); var narudzba_iznos = (int)narudzba.UkupniIznos * 100; if (paymentIntent.Amount == narudzba_iznos && paymentIntent.Status == "succeeded") { if (narudzba.StanjeRezervacije == StanjeRezervacije.ekanje_uplate) { narudzba.StanjeRezervacije = StanjeRezervacije.U_obradi; if (narudzba.DatumUplate is null) { narudzba.DatumUplate = DateTime.Now; } bool IsServisRezervacija = narudzba.RezervacijaServis.Any(), IsTerminRezervacija = narudzba.RezervacijaIznajmljenaBicikla.Any(); if (IsServisRezervacija || IsTerminRezervacija || narudzba.NacinPlacanja == "online") { var zaposlenici = db.Zaposlenik.Where(x => x.Korisnik.Aktivan == true).ToList(); foreach (var zaposlenik in zaposlenici) { var notifikacija = new Notifikacija { ZaposlenikId = zaposlenik.Id, Rezervacija = narudzba, DatumVrijeme = DateTime.Now }; if (IsServisRezervacija) { notifikacija.Tip = TipNotifikacije.Novi_Servis; } else if (IsTerminRezervacija) { notifikacija.Tip = TipNotifikacije.Novi_Termin; } else { notifikacija.Tip = TipNotifikacije.Nova_Narudzba; } db.Notifikacija.Add(notifikacija); } } db.SaveChanges(); } } return(new JsonResult(new { success = true })); }
public IActionResult OffSessionPayment(string customerId, long amount) { try { //var amountt=long.Parse(amount); var methodOptions = new PaymentMethodListOptions { Customer = customerId, Type = "card", }; var methodService = new PaymentMethodService(); var paymentMethods = methodService.List(methodOptions); //To get the first payment method var payment = paymentMethods.ToList().FirstOrDefault(); var service = new PaymentIntentService(); var options = new PaymentIntentCreateOptions { Amount = amount /*ProductAmount*//*1099*/, Currency = "usd", Customer = customerId, PaymentMethod = /*PaymentId*//*"card"*/ payment.Id, Confirm = true, OffSession = true, }; var paymentIntentt = service.Create(options); return(Ok()); //return View("ButtonsView"); } catch (StripeException e) { switch (e.StripeError.Error /*.ErrorType*/) { case "card_error": // Error code will be authentication_required if authentication is needed Console.WriteLine("Error code: " + e.StripeError.Code); var paymentIntentId = e.StripeError.PaymentIntent.Id; var service = new PaymentIntentService(); var paymentIntent = service.Get(paymentIntentId); Console.WriteLine(paymentIntent.Id); break; default: break; } //// return(null); } }
public PaymentResponse GetExistingSession(string id) { var service = new PaymentIntentService(); return(new PaymentResponse { Status = "OK", SuccessData = new Dictionary <string, object>() { { "paymentIntent", service.Get(id).ToJson() } } }); }
public override ApiResult FetchPaymentStatus(OrderReadOnly order, StripeCheckoutOneTimeSettings settings) { try { var secretKey = settings.TestMode ? settings.TestSecretKey : settings.LiveSecretKey; ConfigureStripe(secretKey); // See if we have a payment intent to work from var paymentIntentId = order.Properties["stripePaymentIntentId"]; if (!string.IsNullOrWhiteSpace(paymentIntentId)) { var paymentIntentService = new PaymentIntentService(); var paymentIntent = paymentIntentService.Get(paymentIntentId); return(new ApiResult() { TransactionInfo = new TransactionInfoUpdate() { TransactionId = GetTransactionId(paymentIntent), PaymentStatus = GetPaymentStatus(paymentIntent) } }); } // No payment intent, so look for a charge var chargeId = order.Properties["stripeChargeId"]; if (!string.IsNullOrWhiteSpace(chargeId)) { var chargeService = new ChargeService(); var charge = chargeService.Get(chargeId); return(new ApiResult() { TransactionInfo = new TransactionInfoUpdate() { TransactionId = GetTransactionId(charge), PaymentStatus = GetPaymentStatus(charge) } }); } } catch (Exception ex) { Vendr.Log.Error <StripeCheckoutOneTimePaymentProvider>(ex, "Stripe - FetchPaymentStatus"); } return(ApiResult.Empty); }
public override CallbackResult ProcessCallback(OrderReadOnly order, HttpRequestBase request, StripeCheckoutOneTimeSettings settings) { // The ProcessCallback method is only intendid to be called via a Stripe Webhook and so // it's job is to process the webhook event and finalize / update the order accordingly try { var secretKey = settings.TestMode ? settings.TestSecretKey : settings.LiveSecretKey; var webhookSigningSecret = settings.TestMode ? settings.TestWebhookSigningSecret : settings.LiveWebhookSigningSecret; ConfigureStripe(secretKey); var stripeEvent = GetWebhookStripeEvent(request, webhookSigningSecret); if (stripeEvent != null && stripeEvent.Type == Events.CheckoutSessionCompleted) { if (stripeEvent.Data?.Object?.Instance is Session stripeSession) { var paymentIntentService = new PaymentIntentService(); var paymentIntent = paymentIntentService.Get(stripeSession.PaymentIntentId); return(CallbackResult.Ok(new TransactionInfo { TransactionId = GetTransactionId(paymentIntent), AmountAuthorized = AmountFromMinorUnits(paymentIntent.Amount), PaymentStatus = GetPaymentStatus(paymentIntent) }, new Dictionary <string, string> { { "stripeSessionId", stripeSession.Id }, { "stripePaymentIntentId", stripeSession.PaymentIntentId }, { "stripeChargeId", GetTransactionId(paymentIntent) }, { "stripeCardCountry", paymentIntent.Charges?.Data?.FirstOrDefault()?.PaymentMethodDetails?.Card?.Country } })); } } } catch (Exception ex) { Vendr.Log.Error <StripeCheckoutOneTimePaymentProvider>(ex, "Stripe - ProcessCallback"); } return(CallbackResult.BadRequest()); }
public ActionResult <StripeResult> Get([FromBody] StripeChargeRequest request) { StripeConfiguration.ApiKey = StripeApiKey; StripeResult result = new StripeResult(); PaymentIntentService service = new PaymentIntentService(); try { PaymentIntent charge = service.Get(request.Id); result.Data = charge; result.Success = true; } catch (StripeException exception) { result.Success = false; result.Error = _stripeErrorHandler.ErrorHandler(exception); } return(result); }
public override int ThreeDSecureCheck(string providerRef, string merchantRef = "", string data1 = "", string data2 = "", string data3 = "") { // Return // 0 : Payment succeeded // 1-999 : Payment processed but declined or rejected // 1001- : Internal error int ret = 10010; resultCode = "XX"; resultMsg = "Internal failure"; err = ""; try { ret = 10020; StripeConfiguration.ApiKey = Tools.ProviderCredentials("Stripe", "SecretKey"); ret = 10030; var paymentIntentService = new PaymentIntentService(); ret = 10040; // var paymentIntent = paymentIntentService.Get(clientSecretId); var paymentIntent = paymentIntentService.Get(providerRef); ret = 10050; resultCode = paymentIntent.Status; ret = 10060; if (resultCode.ToUpper().StartsWith("SUCCE")) { resultMsg = "Payment successful"; return(0); } resultMsg = "Payment NOT successful; further action required"; return(37); } catch (Exception ex) { Tools.LogInfo("ThreeDSecureCheck/198", "Ret=" + ret.ToString(), 222, this); Tools.LogException("ThreeDSecureCheck/199", "Ret=" + ret.ToString(), ex, this); } return(ret); }
public override async Task <OrderReference> GetOrderReferenceAsync(PaymentProviderContext <TSettings> ctx) { try { var secretKey = ctx.Settings.TestMode ? ctx.Settings.TestSecretKey : ctx.Settings.LiveSecretKey; var webhookSigningSecret = ctx.Settings.TestMode ? ctx.Settings.TestWebhookSigningSecret : ctx.Settings.LiveWebhookSigningSecret; ConfigureStripe(secretKey); var stripeEvent = await GetWebhookStripeEventAsync(ctx, webhookSigningSecret); if (stripeEvent != null && stripeEvent.Type == Events.CheckoutSessionCompleted) { if (stripeEvent.Data?.Object?.Instance is Session stripeSession && !string.IsNullOrWhiteSpace(stripeSession.ClientReferenceId)) { return(OrderReference.Parse(stripeSession.ClientReferenceId)); } } else if (stripeEvent != null && stripeEvent.Type == Events.ReviewClosed) { if (stripeEvent.Data?.Object?.Instance is Review stripeReview && !string.IsNullOrWhiteSpace(stripeReview.PaymentIntentId)) { var paymentIntentService = new PaymentIntentService(); var paymentIntent = paymentIntentService.Get(stripeReview.PaymentIntentId); if (paymentIntent != null && paymentIntent.Metadata.ContainsKey("orderReference")) { return(OrderReference.Parse(paymentIntent.Metadata["orderReference"])); } } } } catch (Exception ex) { _logger.Error(ex, "Stripe - GetOrderReference"); } return(await base.GetOrderReferenceAsync(ctx)); }
public override ApiInfo GetStatus(Order order, IDictionary <string, string> settings) { try { order.MustNotBeNull("order"); settings.MustNotBeNull("settings"); settings.MustContainKey("mode", "settings"); settings.MustContainKey(settings["mode"] + "_secret_key", "settings"); var apiKey = settings[settings["mode"] + "_secret_key"]; ConfigureStripe(apiKey); // See if we have a payment intent ID to work from var paymentIntentId = order.Properties["stripePaymentIntentId"]; if (!string.IsNullOrWhiteSpace(paymentIntentId)) { var paymentIntentService = new PaymentIntentService(); var paymentIntentGetOptions = new PaymentIntentGetOptions(); var paymentIntent = paymentIntentService.Get(paymentIntentId, paymentIntentGetOptions); return(new ApiInfo(GetTransactionId(paymentIntent), GetPaymentState(paymentIntent))); } // No payment intent, so look for a charge ID if (!string.IsNullOrWhiteSpace(order.TransactionInformation.TransactionId)) { var chargeService = new ChargeService(); var charge = chargeService.Get(order.TransactionInformation.TransactionId); return(new ApiInfo(GetTransactionId(charge), GetPaymentState(charge))); } } catch (Exception exp) { LoggingService.Instance.Error <Stripe>("Stripe(" + order.OrderNumber + ") - GetStatus", exp); } return(null); }
public InvoiceInfo GeneratePayNowLink( string customerEmail, decimal amountToPay, string currency, string description = "") { try { CustomerCreateOptions customerInfo = new CustomerCreateOptions { Email = customerEmail, //PaymentMethod = "card", }; var customerService = new CustomerService(); var customer = customerService.Create(customerInfo); var invoiceItemOption = new InvoiceItemCreateOptions { Customer = customer.Id, Amount = Convert.ToInt32(amountToPay * 100), Currency = currency, }; var invoiceItemService = new InvoiceItemService(); var invoiceItem = invoiceItemService.Create(invoiceItemOption); var invoiceOptions = new InvoiceCreateOptions { Customer = customer.Id, CollectionMethod = "send_invoice", DaysUntilDue = 30, Description = description }; var service = new InvoiceService(); var invoice = service.Create(invoiceOptions); invoice = service.FinalizeInvoice(invoice.Id); try { var paymentIntentService = new PaymentIntentService(); var paymentIntent = paymentIntentService.Get(invoice.PaymentIntentId); var paymentIntentUpdateOptions = new PaymentIntentUpdateOptions { Description = description }; paymentIntentService.Update(paymentIntent.Id, paymentIntentUpdateOptions); } catch (Exception) { //continue } var result = new InvoiceInfo { Url = invoice.HostedInvoiceUrl, Id = invoice.Id }; return(result); } catch (Exception e) { Console.WriteLine(e); return(null); } }
public override async Task <CallbackResult> ProcessCallbackAsync(PaymentProviderContext <StripeCheckoutSettings> ctx) { // The ProcessCallback method is only intendid to be called via a Stripe Webhook and so // it's job is to process the webhook event and finalize / update the ctx.Order accordingly try { var secretKey = ctx.Settings.TestMode ? ctx.Settings.TestSecretKey : ctx.Settings.LiveSecretKey; var webhookSigningSecret = ctx.Settings.TestMode ? ctx.Settings.TestWebhookSigningSecret : ctx.Settings.LiveWebhookSigningSecret; ConfigureStripe(secretKey); var stripeEvent = await GetWebhookStripeEventAsync(ctx, webhookSigningSecret); if (stripeEvent != null && stripeEvent.Type == Events.CheckoutSessionCompleted) { if (stripeEvent.Data?.Object?.Instance is Session stripeSession) { if (stripeSession.Mode == "payment") { var paymentIntentService = new PaymentIntentService(); var paymentIntent = await paymentIntentService.GetAsync(stripeSession.PaymentIntentId, new PaymentIntentGetOptions { Expand = new List <string>(new[] { "review" }) }); return(CallbackResult.Ok(new TransactionInfo { TransactionId = GetTransactionId(paymentIntent), AmountAuthorized = AmountFromMinorUnits(paymentIntent.Amount), PaymentStatus = GetPaymentStatus(paymentIntent) }, new Dictionary <string, string> { { "stripeSessionId", stripeSession.Id }, { "stripeCustomerId", stripeSession.CustomerId }, { "stripePaymentIntentId", stripeSession.PaymentIntentId }, { "stripeSubscriptionId", stripeSession.SubscriptionId }, { "stripeChargeId", GetTransactionId(paymentIntent) }, { "stripeCardCountry", paymentIntent.Charges?.Data?.FirstOrDefault()?.PaymentMethodDetails?.Card?.Country } })); } else if (stripeSession.Mode == "subscription") { var subscriptionService = new SubscriptionService(); var subscription = await subscriptionService.GetAsync(stripeSession.SubscriptionId, new SubscriptionGetOptions { Expand = new List <string>(new[] { "latest_invoice", "latest_invoice.charge", "latest_invoice.charge.review", "latest_invoice.payment_intent", "latest_invoice.payment_intent.review" }) }); var invoice = subscription.LatestInvoice; return(CallbackResult.Ok(new TransactionInfo { TransactionId = GetTransactionId(invoice), AmountAuthorized = AmountFromMinorUnits(invoice.PaymentIntent.Amount), PaymentStatus = GetPaymentStatus(invoice) }, new Dictionary <string, string> { { "stripeSessionId", stripeSession.Id }, { "stripeCustomerId", stripeSession.CustomerId }, { "stripePaymentIntentId", invoice.PaymentIntentId }, { "stripeSubscriptionId", stripeSession.SubscriptionId }, { "stripeChargeId", invoice.ChargeId }, { "stripeCardCountry", invoice.Charge?.PaymentMethodDetails?.Card?.Country } })); } } else if (stripeEvent != null && stripeEvent.Type == Events.ReviewClosed) { if (stripeEvent.Data?.Object?.Instance is Review stripeReview && !string.IsNullOrWhiteSpace(stripeReview.PaymentIntentId)) { var paymentIntentService = new PaymentIntentService(); var paymentIntent = paymentIntentService.Get(stripeReview.PaymentIntentId, new PaymentIntentGetOptions { Expand = new List <string>(new[] { "review" }) }); return(CallbackResult.Ok(new TransactionInfo { TransactionId = GetTransactionId(paymentIntent), AmountAuthorized = AmountFromMinorUnits(paymentIntent.Amount), PaymentStatus = GetPaymentStatus(paymentIntent) })); } } } } catch (Exception ex) { _logger.Error(ex, "Stripe - ProcessCallback"); } return(CallbackResult.BadRequest()); }
public async Task <IActionResult> Webhook() { var json = await new StreamReader(HttpContext.Request.Body).ReadToEndAsync(); Event stripeEvent; try { stripeEvent = EventUtility.ConstructEvent( json, Request.Headers["Stripe-Signature"], this.options.Value.WebhookSecret ); Console.WriteLine($"Webhook notification with type: {stripeEvent.Type} found for {stripeEvent.Id}"); } catch (Exception e) { Console.WriteLine($"Something failed {e}"); return(BadRequest()); } if (stripeEvent.Type == "invoice.payment_succeeded") { var invoice = stripeEvent.Data.Object as Invoice; if (invoice.BillingReason == "subscription_create") { // The subscription automatically activates after successful payment // Set the payment method used to pay the first invoice // as the default payment method for that subscription // Retrieve the payment intent used to pay the subscription var service = new PaymentIntentService(); var paymentIntent = service.Get(invoice.PaymentIntentId); // Set the default payment method var options = new SubscriptionUpdateOptions { DefaultPaymentMethod = paymentIntent.PaymentMethodId, }; var subscriptionService = new SubscriptionService(); subscriptionService.Update(invoice.SubscriptionId, options); Console.WriteLine($"Default payment method set for subscription: {paymentIntent.PaymentMethodId}"); } Console.WriteLine($"Payment succeeded for invoice: {stripeEvent.Id}"); } if (stripeEvent.Type == "invoice.paid") { // Used to provision services after the trial has ended. // The status of the invoice will show up as paid. Store the status in your // database to reference when a user accesses your service to avoid hitting rate // limits. } if (stripeEvent.Type == "invoice.payment_failed") { // If the payment fails or the customer does not have a valid payment method, // an invoice.payment_failed event is sent, the subscription becomes past_due. // Use this webhook to notify your user that their payment has // failed and to retrieve new card details. } if (stripeEvent.Type == "invoice.finalized") { // If you want to manually send out invoices to your customers // or store them locally to reference to avoid hitting Stripe rate limits. } if (stripeEvent.Type == "customer.subscription.deleted") { // handle subscription cancelled automatically based // upon your subscription settings. Or if the user cancels it. } if (stripeEvent.Type == "customer.subscription.trial_will_end") { // Send notification to your user that the trial will end } return(Ok()); }
public string SendInvoice( string customerEmail, decimal amountToPay, string currency, string description = "", bool sendInvoice = true) { try { CustomerCreateOptions customerInfo = new CustomerCreateOptions { Email = customerEmail, //PaymentMethod = "card", }; var customerService = new CustomerService(); var customer = customerService.Create(customerInfo); var invoiceItemOption = new InvoiceItemCreateOptions { Customer = customer.Id, Amount = Convert.ToInt32(amountToPay * 100), Currency = currency, }; var invoiceItemService = new InvoiceItemService(); var invoiceItem = invoiceItemService.Create(invoiceItemOption); var invoiceOptions = new InvoiceCreateOptions { Customer = customer.Id, CollectionMethod = "send_invoice", DaysUntilDue = 30, Description = description, AutoAdvance = true }; var service = new InvoiceService(); var invoice = service.Create(invoiceOptions); invoice = service.FinalizeInvoice(invoice.Id); try { var paymentIntentService = new PaymentIntentService(); var paymentIntent = paymentIntentService.Get(invoice.PaymentIntentId); var paymentIntentUpdateOptions = new PaymentIntentUpdateOptions { Description = description }; paymentIntentService.Update(paymentIntent.Id, paymentIntentUpdateOptions); } catch (Exception) { //continue } if (sendInvoice) { invoice = service.SendInvoice(invoice.Id); } return(invoice.Id); } catch (Exception e) { Console.WriteLine(e); return(null); } }
public async System.Threading.Tasks.Task <ActionResult> statusPayment(string id) { try { var service = new PaymentIntentService(); var intent = service.Get(id); if (intent.Status.Contains("succeeded")) { int iid = int.Parse(intent.Metadata["invoiceID"]); var transaction = new Models.Database.Transaction { invoiceid = iid, paymentmethodid = 1, reference = id, total = decimal.Parse((Convert.ToDecimal(intent.Amount) / 100).ToString(".00")), transdate = DateTime.Now }; db.Transactions.Add(transaction); db.SaveChanges(); var invoice = db.Invoices.Find(iid); //invoice.totalunpaid -= decimal.Parse((intent.Amount / 100).ToString(".00")); //invoice.status = "Paid"; //db.Entry(invoice).State = System.Data.Entity.EntityState.Modified; //db.SaveChanges(); //var job = db.Jobs.Find(invoice.jobid); //job.jobstatusid = 1; //db.SaveChanges(); //Remove Data from Firebase (Quoted Items) var userTrans = db.Transactions.Where(x => x.Invoice.jobid == invoice.jobid); if (userTrans.Count() == 1) { var userInvoice = userTrans.FirstOrDefault().Invoice.Job; var package = userInvoice.Package; var userid = userInvoice.User.id; var chatkey = package.Studio.ChatKeys.FirstOrDefault(x => x.UserID == userid).ChatKeyID; FirestoreDb firestore = FirestoreDb.Create("photogw2"); var collection = firestore.Collection("Quotation"); var query = collection.WhereEqualTo("ChatKey", chatkey); var snapshot = await query.GetSnapshotAsync(); var deserializedDataQuoteAll = snapshot.FirstOrDefault().ConvertTo <QuotationModel>(); var chat = db.ChatKeys.FirstOrDefault(x => x.ChatKeyID == deserializedDataQuoteAll.ChatKey); var deserializedDataSel = deserializedDataQuoteAll.Packages.FirstOrDefault(x => x.Package.Id == package.id); deserializedDataQuoteAll.Packages.Remove(deserializedDataSel); await collection.Document(snapshot.FirstOrDefault().Id).SetAsync(deserializedDataQuoteAll); } return(View("success", db.Transactions.FirstOrDefault(x => x.invoiceid == iid))); } else { return(View("cancel")); } } catch (Exception e) { return(RedirectToAction("Error500", "Home", new { errormsg = e.Message })); } }
protected async Task <StripeWebhookEvent> GetWebhookStripeEventAsync(PaymentProviderContext <TSettings> ctx, string webhookSigningSecret) { StripeWebhookEvent stripeEvent = null; if (ctx.AdditionalData.ContainsKey("Vendr_StripeEvent")) { stripeEvent = (StripeWebhookEvent)ctx.AdditionalData["Vendr_StripeEvent"]; } else { try { var json = await ctx.Request.Content.ReadAsStringAsync(); var stripeSignature = ctx.Request.Headers.GetValues("Stripe-Signature").FirstOrDefault(); // Just validate the webhook signature EventUtility.ValidateSignature(json, stripeSignature, webhookSigningSecret); // Parse the event ourselves to our custom webhook event model // as it only captures minimal object information. stripeEvent = JsonConvert.DeserializeObject <StripeWebhookEvent>(json); // We manually fetch the event object type ourself as it means it will be fetched // using the same API version as the payment providers is coded against. // NB: Only supports a number of object types we are likely to be interested in. if (stripeEvent?.Data?.Object != null) { switch (stripeEvent.Data.Object.Type) { case "checkout.session": var sessionService = new SessionService(); stripeEvent.Data.Object.Instance = sessionService.Get(stripeEvent.Data.Object.Id); break; case "charge": var chargeService = new ChargeService(); stripeEvent.Data.Object.Instance = chargeService.Get(stripeEvent.Data.Object.Id); break; case "payment_intent": var paymentIntentService = new PaymentIntentService(); stripeEvent.Data.Object.Instance = paymentIntentService.Get(stripeEvent.Data.Object.Id); break; case "subscription": var subscriptionService = new SubscriptionService(); stripeEvent.Data.Object.Instance = subscriptionService.Get(stripeEvent.Data.Object.Id); break; case "invoice": var invoiceService = new InvoiceService(); stripeEvent.Data.Object.Instance = invoiceService.Get(stripeEvent.Data.Object.Id); break; case "review": var reviewService = new ReviewService(); stripeEvent.Data.Object.Instance = reviewService.Get(stripeEvent.Data.Object.Id); break; } } ctx.AdditionalData.Add("Vendr_StripeEvent", stripeEvent); } catch (Exception ex) { _logger.Error(ex, "Stripe - GetWebhookStripeEvent"); } } return(stripeEvent); }
async void placeOrder(object sender, System.EventArgs e) { var request = new HttpRequestMessage(); request.RequestUri = new Uri("http://10.0.2.2:5000/api/v1/payment"); request.Method = HttpMethod.Get; var client = new HttpClient(); MultipartFormDataContent requestContent = new MultipartFormDataContent(); StringContent amountContent = new StringContent("9923", Encoding.UTF8); requestContent.Add(amountContent, "amount"); request.Content = requestContent; HttpResponseMessage response = await client.SendAsync(request); StripeConfiguration.ApiKey = "pk_test_j5YImiDFgybfafp8HuEkn6Ou00JtFKI0s9"; if (response.StatusCode == System.Net.HttpStatusCode.OK) { HttpContent content = response.Content; var responseString = await content.ReadAsStringAsync(); var messageObj = JsonConvert.DeserializeObject <message>(responseString); var client_secret = messageObj.client_secret; var service = new PaymentIntentService(); var getOptions = new PaymentIntentGetOptions { ClientSecret = client_secret }; PaymentIntent paymentIntent = service.Get(messageObj.id, getOptions); //var creditCardOptions = new CreditCardOptions //{ // Number = "4000 0000 0000 9995", // Cvc = "333", // ExpMonth = 02, // ExpYear = 24, //}; var paymentMethodCardCreateOption = new PaymentMethodCardCreateOptions { //Insufficiant fund //Number = "4000000000009995", //Payment Succeed //Number = "4242424242424242", //Payment Require Authentication //Number = "4000002500003155", Number = CreditCardNumber.Text, Cvc = CVC.Text, ExpMonth = long.Parse(ExpMonth.Text), ExpYear = long.Parse(ExpYear.Text), }; //var paymentMethodDataOption = new PaymentIntentPaymentMethodDataOptions //{ // Card = paymentMethodCardCreateOption, // Type = "card", //}; List <String> methodTypes = new List <String>(); methodTypes.Add("pm_card_visa"); var confirmOptions = new PaymentIntentConfirmOptions { //PaymentMethod = "pm_card_visa", PaymentMethodData = paymentMethodDataOption, ClientSecret = client_secret, }; try { var status = service.Confirm(messageObj.id, confirmOptions); if (status.Status == "succeeded") { await DisplayAlert("Request Sent!", "Our customer service will reach out to you in 3-5 bussiness days", "OK"); } else { await DisplayAlert("Failed", "Please try another card", "OK"); } } catch (Exception) { await DisplayAlert("Failed", "Please try another card", "OK"); } //Console.WriteLine(status.Status); } }
protected StripeWebhookEvent GetWebhookStripeEvent(HttpRequestBase request, string webhookSigningSecret) { StripeWebhookEvent stripeEvent = null; if (HttpContext.Current.Items["Vendr_StripeEvent"] != null) { stripeEvent = (StripeWebhookEvent)HttpContext.Current.Items["Vendr_StripeEvent"]; } else { try { if (request.InputStream.CanSeek) { request.InputStream.Seek(0, SeekOrigin.Begin); } using (var reader = new StreamReader(request.InputStream)) { var json = reader.ReadToEnd(); // Just validate the webhook signature EventUtility.ValidateSignature(json, request.Headers["Stripe-Signature"], webhookSigningSecret); // Parse the event ourselves to our custom webhook event model // as it only captures minimal object information. stripeEvent = JsonConvert.DeserializeObject <StripeWebhookEvent>(json); // We manually fetch the event object type ourself as it means it will be fetched // using the same API version as the payment providers is coded against. // NB: Only supports a number of object types we are likely to be interested in. if (stripeEvent?.Data?.Object != null) { switch (stripeEvent.Data.Object.Type) { case "checkout.session": var sessionService = new SessionService(); stripeEvent.Data.Object.Instance = sessionService.Get(stripeEvent.Data.Object.Id); break; case "charge": var chargeService = new ChargeService(); stripeEvent.Data.Object.Instance = chargeService.Get(stripeEvent.Data.Object.Id); break; case "payment_intent": var paymentIntentService = new PaymentIntentService(); stripeEvent.Data.Object.Instance = paymentIntentService.Get(stripeEvent.Data.Object.Id); break; case "subscription": var subscriptionService = new SubscriptionService(); stripeEvent.Data.Object.Instance = subscriptionService.Get(stripeEvent.Data.Object.Id); break; case "invoice": var invoiceService = new InvoiceService(); stripeEvent.Data.Object.Instance = invoiceService.Get(stripeEvent.Data.Object.Id); break; } } HttpContext.Current.Items["Vendr_StripeEvent"] = stripeEvent; } } catch (Exception ex) { Vendr.Log.Error <StripePaymentProviderBase <TSettings> >(ex, "Stripe - GetWebhookStripeEvent"); } } return(stripeEvent); }
public PaymentIntent GetPaymentIntentById(string id) { var paymentIntentService = new PaymentIntentService(); return(paymentIntentService.Get(id)); }