public async Task <IEnumerable <TransactionDTO> > Execute(PaymentModel payment) { var customer = await _paymentRepository.GetLastTransaction(payment.OrderId); var service = new RefundService(); var options = new RefundCreateOptions { Charge = customer.ExternalId, }; var orderInfo = new PaymentModel { UserId = customer.UserId, VendorId = customer.VendorId, OrderId = customer.OrderId, Amount = customer.Amount }; var transaction = await _retryHelper.RetryIfThrown(async() => { var result = await service.CreateAsync(options); var test = _mappingProvider.GetMappingOperation(PaymentServiceConstants.PaymentMappingType.Stripe_Refund) .Map(PaymentServiceConstants.PaymentType.Refund, orderInfo, result, result.Created); return(test); }, PaymentServiceConstants.PaymentType.Refund, orderInfo, PaymentServiceConstants.isSucceeded.Succeeded); return(await _paymentRepository.CreateTransactions(transaction)); }
public ActionResult Refund() { try { StripeConfiguration.ApiKey = key; StripeConfiguration.MaxNetworkRetries = 2; var refunds = new RefundService(); var refundOptions = new RefundCreateOptions { PaymentIntent = paymentIntent }; var refund = refunds.Create(refundOptions); return(View("OrderStatus")); } catch (StripeException e) { var x = new { status = "Failed", message = e.Message }; return(this.Json(x)); } }
public IActionResult CancelOrder(int id) { OrderHeader orderHeader = _unitOfWork.OrderHeader.GetFirstOrDefault(u => u.Id == id); if (orderHeader.PaymentStatus == SD.StatusApproved) { //Stripe entities var options = new RefundCreateOptions { Amount = Convert.ToInt32(orderHeader.OrderTotal * 100), Reason = RefundReasons.RequestedByCustomer, Charge = orderHeader.TransactionId }; var service = new RefundService(); Refund refund = service.Create(options); orderHeader.OrderStatus = SD.StatusRefunded; orderHeader.PaymentStatus = SD.StatusRefunded; //after giving them the refund in stripe change the orderHeader niformation accordingly } //if unable to refund just cancel the order. else { orderHeader.OrderStatus = SD.StatusCancelled; orderHeader.PaymentStatus = SD.StatusCancelled; } _unitOfWork.Save(); return(RedirectToAction("Index")); }
public async void chargeGroceryAmount() { try { StripeConfiguration.SetApiKey("sk_test_Q5wSnyXL03yN0KpPaAMYttOb"); var options = new RefundCreateOptions { ChargeId = jobChargeId }; var service = new RefundService(); Refund refund = service.Create(options); double amount = Convert.ToDouble(totalAmounts); var charge = new ChargeCreateOptions { Amount = Convert.ToInt32(amount * 100), // In cents, not dollars, times by 100 to convert Currency = "aud", // or the currency you are dealing with CustomerId = "cus_Dxa4I8cQgAL7D7" //Convert.ToString(userData["stripeCustomerId"]), }; var services = new ChargeService(); var response = services.Create(charge); await DisplayAlert("", "Successfully Charge Amount: " + amount, "Ok"); } catch (Exception ex) { await DisplayAlert("", ExceptionManagement.LogException(ex), "Ok"); } }
public RefundServiceTest( StripeMockFixture stripeMockFixture, MockHttpClientFixture mockHttpClientFixture) : base(stripeMockFixture, mockHttpClientFixture) { this.service = new RefundService(this.StripeClient); this.createOptions = new RefundCreateOptions { Amount = 123, Charge = "ch_123", }; this.updateOptions = new RefundUpdateOptions { Metadata = new Dictionary <string, string> { { "key", "value" }, }, }; this.listOptions = new RefundListOptions { Limit = 1, }; }
public IActionResult CancelOrder(int id) { OrderHeader orderHeader = _unitOfWork.OrderHeader.GetFirstOrDefault(u => u.Id == id); if (orderHeader.PaymentStatus == SD.StatusApproved) { var options = new RefundCreateOptions { Amount = Convert.ToInt32(orderHeader.OrderTotal * 100), Reason = RefundReasons.RequestedByCustomer, Charge = orderHeader.TransactionId }; var service = new RefundService(); Refund refund = service.Create(options); orderHeader.OrderStatus = SD.StatusRefunded; orderHeader.PaymentStatus = SD.StatusRefunded; } else { orderHeader.OrderStatus = SD.StatusCancelled; orderHeader.PaymentStatus = SD.StatusCancelled; } _unitOfWork.Save(); return(RedirectToAction("Index")); }
public ActionResult DeleteConfirmed(int id) { //Debug Purpose to see if we are getting the id Debug.WriteLine("I'm pulling data of " + id.ToString()); //Get the specific Donation Donation donation = db.Donations.Find(id); //Refund the donated amount back to the user //Code Referenced from: https://stripe.com/docs/refunds StripeConfiguration.ApiKey = "sk_test_T3BF2ap8TTDpmetCKxF038r400HAf7zrj8"; var refunds = new RefundService(); var refundOptions = new RefundCreateOptions { PaymentIntent = donation.donationReceiptId, Amount = donation.donationAmount }; var refund = refunds.Create(refundOptions); //Delete that specific Donation from the database db.Donations.Remove(donation); //Save the changes on the database db.SaveChanges(); //Go back to the list of Donation to see the removed Donation return(RedirectToAction("Index")); }
public string Refund(string toggleRefund) { //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 //sk_test_51Gzaa1HAh8lBnQxza9cOAzY7LbfgQ4FWX2sYqiuHsoVWJg4mNDppueQkAVd0XIPU4GhcrNBca8aemNgr24m4jDv200ooFw0Bhz StripeConfiguration.ApiKey = "sk_test_51Gzaa1HAh8lBnQxza9cOAzY7LbfgQ4FWX2sYqiuHsoVWJg4mNDppueQkAVd0XIPU4GhcrNBca8aemNgr24m4jDv200ooFw0Bhz"; var msg = ""; if (toggleRefund == "refund") { var refunds = new RefundService(); var refundOptions = new RefundCreateOptions { PaymentIntent = "pi_1GzxFMHAh8lBnQxzpA2OSATN" }; var refund = refunds.Create(refundOptions); msg = "Payment refunded successfully"; } else if (toggleRefund == "cancelRefund") { var service = new PaymentIntentService(); var options = new PaymentIntentCancelOptions { }; var intent = service.Cancel("pi_1GzxFMHAh8lBnQxzpA2OSATN", options); msg = "Payment refund cancelled"; } //ViewBag.message = msg; return(msg); }
public IActionResult CancelOrder(int id) { var orderHeader = _unitOfWork.OrderHeader.FirstOrDefault(c => c.Id == id); //We want refund if only the status was approved for the initial payment because if the status was for a delayed company we dont want to process a refund for them if (orderHeader.PaymentStatus == SD.StatusApproved) { var options = new RefundCreateOptions { Amount = Convert.ToInt32(orderHeader.OrderTotal * 100), Reason = RefundReasons.RequestedByCustomer, Charge = orderHeader.TransactionId }; var service = new RefundService(); var refund = service.Create(options); orderHeader.OrderStatus = SD.StatusCancelled; orderHeader.PaymentStatus = SD.StatusCancelled; } else { orderHeader.OrderStatus = SD.StatusCancelled; orderHeader.PaymentStatus = SD.StatusCancelled; } _unitOfWork.Save(); return(RedirectToAction(nameof(Index))); }
public IActionResult OnPostOrderRefund(int orderId) { OrderHeader orderHeader = _unitOfWork.OrderHeader.GetFirstOrDefault(o => o.Id == orderId); //refund the amount //go to stripe and find the documentation in refund //copy the post call in refunds documentation // this is the code of refund var options = new RefundCreateOptions { Amount = Convert.ToInt32(orderHeader.OrderTotal * 100), Reason = RefundReasons.RequestedByCustomer, //something wrong with charge. I think that is ChargeId Charge = orderHeader.TransactionId }; var service = new RefundService(); //Refund refund = service.Create("myAPI coedes", refundOptions); Refund refund = service.Create(options); orderHeader.Status = SD.StatusRefunded; _unitOfWork.Save(); return(RedirectToPage("ManageOrder")); }
public override async Task <ApiResult> RefundPaymentAsync(PaymentProviderContext <StripeCheckoutSettings> ctx) { try { // We can only refund a captured charge, so make sure we have one // otherwise there is nothing we can do var chargeId = ctx.Order.Properties["stripeChargeId"]; if (string.IsNullOrWhiteSpace(chargeId)) { return(null); } var secretKey = ctx.Settings.TestMode ? ctx.Settings.TestSecretKey : ctx.Settings.LiveSecretKey; ConfigureStripe(secretKey); var refundService = new RefundService(); var refundCreateOptions = new RefundCreateOptions() { Charge = chargeId }; var refund = refundService.Create(refundCreateOptions); var charge = refund.Charge ?? await new ChargeService().GetAsync(refund.ChargeId); // If we have a subscription then we'll cancel it as refunding an ctx.Order // should effecitvely undo any purchase if (!string.IsNullOrWhiteSpace(ctx.Order.Properties["stripeSubscriptionId"])) { var subscriptionService = new SubscriptionService(); var subscription = await subscriptionService.GetAsync(ctx.Order.Properties["stripeSubscriptionId"]); if (subscription != null) { subscriptionService.Cancel(ctx.Order.Properties["stripeSubscriptionId"], new SubscriptionCancelOptions { InvoiceNow = false, Prorate = false }); } } return(new ApiResult() { TransactionInfo = new TransactionInfoUpdate() { TransactionId = GetTransactionId(charge), PaymentStatus = GetPaymentStatus(charge) } }); } catch (Exception ex) { _logger.Error(ex, "Stripe - RefundPayment"); } return(ApiResult.Empty); }
public override ApiResult RefundPayment(OrderReadOnly order, StripeCheckoutSettings settings) { try { // We can only refund a captured charge, so make sure we have one // otherwise there is nothing we can do var chargeId = order.Properties["stripeChargeId"]; if (string.IsNullOrWhiteSpace(chargeId)) { return(null); } var secretKey = settings.TestMode ? settings.TestSecretKey : settings.LiveSecretKey; ConfigureStripe(secretKey); var refundService = new RefundService(); var refundCreateOptions = new RefundCreateOptions() { Charge = chargeId }; var refund = refundService.Create(refundCreateOptions); var charge = refund.Charge ?? new ChargeService().Get(refund.ChargeId); // If we have a subscription then we'll cancel it as refunding an order // should effecitvely undo any purchase if (!string.IsNullOrWhiteSpace(order.Properties["stripeSubscriptionId"])) { var subscriptionService = new SubscriptionService(); var subscription = subscriptionService.Get(order.Properties["stripeSubscriptionId"]); if (subscription != null) { subscriptionService.Cancel(order.Properties["stripeSubscriptionId"], new SubscriptionCancelOptions { InvoiceNow = false, Prorate = false }); } } return(new ApiResult() { TransactionInfo = new TransactionInfoUpdate() { TransactionId = GetTransactionId(charge), PaymentStatus = GetPaymentStatus(charge) } }); } catch (Exception ex) { Vendr.Log.Error <StripeCheckoutOneTimePaymentProvider>(ex, "Stripe - RefundPayment"); } return(ApiResult.Empty); }
public virtual async Task <Refund> Create(string chargeId, RefundCreateOptions options = null) { var url = string.Format("{0}/{1}/refunds", Urls.Charges, chargeId); url = this.ApplyAllParameters(options, url, false); var response = await Requestor.Post(url); return(Mapper <Refund> .MapFromJson(response)); }
public async Task <Refund> CreateRefundAsync(string chargeId) { var options = new RefundCreateOptions { Charge = chargeId, }; var service = new Stripe.RefundService(); return(await service.CreateAsync(options)); }
public static Refund RefundPayment(string ChargerID) { StripeConfiguration.SetApiKey(SecretKey); var refundService = new RefundService(); var refundOptions = new RefundCreateOptions { ChargeId = ChargerID, }; Refund refund = refundService.Create(refundOptions); return(refund); }
public async Task <ActionResult> RefundPayment([FromBody] string chargeId) //Full Refund, we can set up amount in refund options for partial refund { var refunds = new RefundService(); var refundOptions = new RefundCreateOptions { Charge = chargeId //Amount = 1000 }; var refund = await refunds.CreateAsync(refundOptions); return(new OkObjectResult(new { Success = "true" })); }
public async Task <RefundDto> CreateRefund(RefundCreateDto dto) { var options = new RefundCreateOptions { ChargeId = dto.ChargeId, Amount = dto.Amount, Reason = RefundReasons.Fraudulent }; var service = new RefundService(); return(RefundMapper.MapRefundToRefundDto(await service.CreateAsync(options))); }
private Refund RefundCharge(string chargeId) { StripeConfiguration.ApiKey = _appKeys.StripeApiKey; var options = new RefundCreateOptions { Charge = chargeId, }; var service = new RefundService(); var refund = service.Create(options); return(refund); }
public async Task <IActionResult> StripeRefund(string paymentRef) { var payment = _context.Payments.SingleOrDefault(x => x.PaymentServiceRef == paymentRef); if (payment == null) { return(NotFound("Payment id not found")); } try { var refunds = new RefundService(); var refundOptions = new RefundCreateOptions { PaymentIntent = paymentRef }; var refund = refunds.Create(refundOptions); } catch (Exception e) { return(BadRequest("Error refunding stripe")); } payment.ExtraDescription = "Refunded: " + payment.Amount; payment.RefundedAt = Format.NorwayDateTimeNow(); payment.Refunded = true; _context.Update(payment); _context.SaveChanges(); var relatedInvoice = _context.Invoices.SingleOrDefault(x => x.PaymentId == payment.Id); if (relatedInvoice == null) { return(Ok()); } relatedInvoice.Paid = false; relatedInvoice.Canceled = true; _context.Update(relatedInvoice); _context.SaveChanges(); return(Ok()); }
public IActionResult CancelOrder(int id) { OrderHeader orderHeader = _unitofwork.OrderHeader.GetFirstOrDefault(u => u.Id == id); if (orderHeader.PaymentStatus == SD.StatusApproved) { var options = new RefundCreateOptions { Amount = Convert.ToInt32(orderHeader.OrderTotal * 100), Reason = RefundReasons.RequestedByCustomer, Charge = orderHeader.TransactionId }; try { var service = new RefundService(); Refund refund = service.Create(options); } catch (Exception x) { } orderHeader.OrderStatus = SD.StatusRefunded; orderHeader.PaymentStatus = SD.StatusRefunded; } else { orderHeader.OrderStatus = SD.StatusCancelled; orderHeader.PaymentStatus = SD.StatusCancelled; } _unitofwork.Save(); //code SMS for CancelOrder SmsTemplate smsTemplate = _db.SmsTemplates.Where(e => e.Id == Convert.ToInt32(EnSmsTemplate.CancelOrder)).FirstOrDefault(); smsTemplate.Content = smsTemplate.Content.Replace("###Name###", orderHeader.Name); TwilioClient.Init(_twilioOptions.AccountSid, _twilioOptions.AuthToken); try { var message = MessageResource.Create( from: new Twilio.Types.PhoneNumber(_twilioOptions.PhoneNumber), to: new Twilio.Types.PhoneNumber(orderHeader.PhoneNumber), body: smsTemplate.Content); } catch (Exception x) { } return(RedirectToAction("Index")); }
private Refund Refund(string chargeId, string stripeAccountId) { var refundService = new RefundService(); var refundOptions = new RefundCreateOptions() { Charge = chargeId }; refundOptions.RefundApplicationFee = true; Refund refund = refundService.Create(refundOptions, new RequestOptions { StripeAccount = stripeAccountId }); return(refund); }
public IActionResult OnPostOrderRefund(int id) { OrderHeader orderHeader = _unitOfWork.OrderHeader.GetFirstOrDefault(o => o.Id == id); var options = new RefundCreateOptions() { Amount = Convert.ToInt32(orderHeader.OrderTotal * 100), Reason = RefundReasons.RequestedByCustomer }; var service = new RefundService(); Refund refund = service.Create(options); orderHeader.Status = SD.StatusRefounded; _unitOfWork.Save(); return(RedirectToPage("OrderList")); }
public IActionResult OnPostOrderRefund(int orderId) { OrderHeader orderHeader = _unitOfWork.OrderHeader.GetFirstOrDefualt(s => s.Id == orderId); //refund amoount var options = new RefundCreateOptions { Amount = Convert.ToInt32(orderHeader.OrderTotal * 100), Reason = RefundReasons.RequestedByCustomer, Charge = orderHeader.TransactionId, }; var service = new RefundService(); Refund refund = service.Create(options); orderHeader.Status = SD.StatusRefunded; _unitOfWork.Save(); return(RedirectToPage("ManagerOrder")); }
//post for Order Refund public IActionResult OnPostOrderRefund(int orderId) { OrderHeader orderHeader = _unitOfWork.OrderHeader.GetFirstOrDefault(o => o.Id == orderId); //refund amoount var options = new RefundCreateOptions { Amount = Convert.ToInt32(orderHeader.OrderTotal * 100), Reason = RefundReasons.RequestedByCustomer, //on customer requste we can put other options as well ChargeId = orderHeader.TransactionId //trcking transaction id for refund }; var service = new RefundService(); Refund refund = service.Create(options); orderHeader.Status = SD.StatusRefunded; _unitOfWork.Save(); return(RedirectToPage("ManageOrder")); }
public Refund Refund(decimal?payAmount, string paymentId, string userId, long orderId, long transactionId, Guid correlationId) { var refunds = new RefundService(); var refundOptions = new RefundCreateOptions { PaymentIntent = paymentId, Amount = (long)(payAmount * 100) }; var refund = refunds.Create(refundOptions); return(refund); }
public override ApiInfo RefundPayment(Order order, IDictionary <string, string> settings) { try { order.MustNotBeNull("order"); settings.MustNotBeNull("settings"); settings.MustContainKey("mode", "settings"); settings.MustContainKey(settings["mode"] + "_secret_key", "settings"); // We can only refund a captured charge, so make sure we have one // otherwise there is nothing we can do if (order.TransactionInformation.TransactionId == null) { return(null); } var apiKey = settings[settings["mode"] + "_secret_key"]; ConfigureStripe(apiKey); var refundService = new RefundService(); var refundCreateOptions = new RefundCreateOptions() { Charge = order.TransactionInformation.TransactionId }; var refund = refundService.Create(refundCreateOptions); var charge = refund.Charge; if (charge == null) { var chargeService = new ChargeService(); charge = chargeService.Get(order.TransactionInformation.TransactionId); } return(new ApiInfo(charge.Id, GetPaymentState(charge))); } catch (Exception exp) { LoggingService.Instance.Error <Stripe>("Stripe(" + order.OrderNumber + ") - RefundPayment", exp); } return(null); }
public static TransactionResult ProcessRefund(TransactionRequest refundRequest, StripeSettings stripeSettings, ILogger logger) { InitStripe(stripeSettings, true); var refundService = new RefundService(); var order = refundRequest.Order; var address = order.BillingAddressSerialized.To <Address>(); GetFinalAmountDetails(refundRequest.Amount ?? refundRequest.Order.OrderTotal, refundRequest.Order.CurrencyCode, address, out _, out var amount); var refundOptions = new RefundCreateOptions { Charge = refundRequest.GetParameterAs <string>("chargeId"), Amount = 100 * (long)(amount), }; var refund = refundService.Create(refundOptions); var refundResult = new TransactionResult() { TransactionGuid = Guid.NewGuid().ToString(), ResponseParameters = new Dictionary <string, object>() { { "sourceTransferReversalId", refund.SourceTransferReversalId }, { "balanceTransactionId", refund.BalanceTransactionId }, { "chargeId", refund.ChargeId }, { "receiptNumber", refund.ReceiptNumber }, }, OrderGuid = refundRequest.Order.Guid, TransactionCurrencyCode = refund.Currency, TransactionAmount = (decimal)refund.Amount / 100 }; if (refund.Status == "failed") { logger.Log <TransactionResult>(LogLevel.Warning, "The refund for Order#" + refundRequest.Order.Id + " by stripe failed." + refund.FailureReason); refundResult.Success = false; refundResult.Exception = new Exception("An error occurred while processing refund"); return(refundResult); } if (refund.Status == "succeeded") { refundResult.NewStatus = refundRequest.IsPartialRefund ? PaymentStatus.RefundedPartially : PaymentStatus.Refunded; refundResult.Success = true; } return(refundResult); }
public async Task <IActionResult> OnPostOrderRefund(int orderId) { var orderHeader = await _unitOfWork.OrderHeaderRepository.GetFirstOrDefaultAsync(x => x.Id == orderId); // refund the amount var options = new RefundCreateOptions { Amount = Convert.ToInt32(orderHeader.OrderTotal * 100), Reason = RefundReasons.RequestedByCustomer, Charge = orderHeader.TransactionId, }; var service = new RefundService(); var refund = service.Create(options); orderHeader.Status = Sd.StatusRefunded; await _unitOfWork.SaveAsync(); return(RedirectToPage("ManageOrder")); }
public IActionResult OnPostOrderRefund(int orderId) { OrderHeader orderheader = _unitOfWork.OrderHeader.GetFirstOrDefault(o => o.Id == orderId); //Refund amount on Stripe var options = new RefundCreateOptions { Amount = Convert.ToInt32(orderheader.OrderTotal * 100), Reason = RefundReasons.RequestedByCustomer, Charge = orderheader.TransactionId }; var service = new RefundService(); service.Create(options); orderheader.Status = StaticDetails.StatusRefunded; _unitOfWork.Save(); return(RedirectToPage("ManageOrder")); }
public async Task <IActionResult> OnPostCancelOrderAsync() { Models.Order orderFromDb = await _orderService.GetOrderSummaryByOrderId(OrderDetails.Order.Id); if (orderFromDb.OrderStatus == SD.OrderStatus.APPROVED || orderFromDb.OrderStatus == SD.OrderStatus.PROCESSING) // Only refund when either of these conditions are met { RefundCreateOptions refundOptions = new RefundCreateOptions { Amount = Convert.ToInt32(orderFromDb.OrderTotal * 100), Reason = RefundReasons.RequestedByCustomer, Charge = orderFromDb.TransactionId }; RefundService refundService = new RefundService(); Refund refund = refundService.Create(refundOptions); orderFromDb.OrderStatus = SD.OrderStatus.REFUNDED; orderFromDb.PaymentStatus = SD.PaymentStatus.REFUNDED; orderFromDb.PaymentDate = DateTime.Now; orderFromDb.UpdatedAt = DateTime.Now; orderFromDb.UpdatedBy = User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier).Value; orderFromDb.OrderActionId = (long)SD.OrderAction.REFUND; } else { orderFromDb.OrderStatus = SD.OrderStatus.CANCELLED; orderFromDb.PaymentStatus = SD.PaymentStatus.CANCELLED; orderFromDb.UpdatedAt = DateTime.Now; orderFromDb.UpdatedBy = User.Claims.FirstOrDefault(x => x.Type == ClaimTypes.NameIdentifier).Value; orderFromDb.OrderActionId = (long)SD.OrderAction.CANCEL; } var isCancelSuccess = await _orderService.Update(orderFromDb); if (!isCancelSuccess) { ErrorMessage = $"Failed to {(orderFromDb.OrderActionId == (long)SD.OrderAction.REFUND ? "refund" : "cancel")} order."; } return(RedirectToPage()); }