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 void MixedRefundOneSfaContribution() { var sut = new RefundService(); var testHistory = new List <Payment> { new Payment { Amount = 50, FundingSource = FundingSourceType.Levy, SfaContributionPercentage = 1m }, new Payment { Amount = 45, FundingSource = FundingSourceType.CoInvestedSfa, SfaContributionPercentage = 0.9m }, new Payment { Amount = 5, FundingSource = FundingSourceType.CoInvestedEmployer, SfaContributionPercentage = 0.9m }, }; var actual = sut.GetRefund(-50, testHistory); actual.Should().HaveCount(2); actual.Single(x => x.EarningType == EarningType.CoInvested).Amount.Should().Be(-25); actual.Single(x => x.EarningType == EarningType.CoInvested).SfaContributionPercentage.Should().Be(0.9m); actual.Single(x => x.EarningType == EarningType.Levy).Amount.Should().Be(-25); actual.Single(x => x.EarningType == EarningType.Levy).SfaContributionPercentage.Should().Be(1m); }
public void NoHistoryReturnsEmptyResult() { var sut = new RefundService(); var actual = sut.GetRefund(-100, new List <Payment>()); actual.Should().BeEmpty(); }
static void Main(string[] args) { const bool isSandbox = false; const string transactionCode = "F3D9490291B54FA59F39B22AB9E76799"; //const decimal refundValue = 150m; EnvironmentConfiguration.ChangeEnvironment(isSandbox); try { var credentials = PagSeguroConfiguration.GetAccountCredentials(isSandbox); // TODO: Substitute the code below with a valid transaction code for your transaction var result = RefundService.RequestRefund(credentials, transactionCode); //var result = RefundService.RequestRefund(credentials, transactionCode, refundValue); Console.WriteLine(result.ToString()); Console.ReadKey(); } catch (PagSeguroServiceException exception) { Console.WriteLine(exception.Message + "\n"); foreach (var element in exception.Errors) { Console.WriteLine(element + "\n"); } Console.ReadKey(); } }
public ResultObj <int> PostRefund([FromBody] List <string> lstTradeNo) { if (lstTradeNo.Count == 0) { return(Content(1)); } IRefund irefund = new RefundService(); List <SaleModel> lstSaleModel = irefund.GetRefundOrder(lstTradeNo); if (lstSaleModel.Count == 0) { return(Content(1)); } //支付宝 var aPayData = from n in lstSaleModel where n.PayInterface == "支付宝" select n; if (aPayData.ToList <SaleModel>().Count > 0) { irefund.PostRefundA(aPayData.ToList <SaleModel>()); } var wPayData = from m in lstSaleModel where m.PayInterface == "微信" select m; if (wPayData.ToList <SaleModel>().Count > 0) { irefund.PostRefundW(wPayData.ToList <SaleModel>()); } return(Content(1)); }
static void getRefundsWithParameters() { // probar los parametros, no funciona bien // transaction es ok // client no funciona // amount es ok // created_at no funciona // count es ok Paymill.ApiKey = Properties.Settings.Default.ApiKey; Paymill.ApiUrl = Properties.Settings.Default.ApiUrl; RefundService refundService = Paymill.GetService <RefundService>(); Console.WriteLine("Waiting request list refunds with parameters..."); Filter filter = new Filter(); filter.Add("count", 5); List <Refund> lstRefunds = refundService.GetRefunds(filter); foreach (Refund refund in lstRefunds) { Console.WriteLine(String.Format("RefundID:{0}", refund.Id)); } Console.Read(); }
private void InitClient(Payment payment) { Client = new StripeClient(payment.PaymentMethod.GetProperty(SecretKey).GetValue().ToString()); ChargeService = new ChargeService(Client); PaymentIntentService = new PaymentIntentService(Client); RefundService = new RefundService(Client); }
public RefundServiceTest( StripeMockFixture stripeMockFixture, MockHttpClientFixture mockHttpClientFixture) : base(stripeMockFixture, mockHttpClientFixture) { this.service = new RefundService(this.StripeClient); this.createOptions = new RefundCreateOptions { Amount = 123, ChargeId = "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.PaymentStatusRejected; } _unitOfWork.Save(); return(RedirectToAction("Index")); }
public ActionResult ValidateRefund(string OrderID, string TelePhone, string CodeStr) { var validateResult = new CodeService().ValidateCodeWithOutTime(TelePhone, CodeStr, Code_Type.Refund); if (!(validateResult != null && validateResult.status > 0)) { ViewBag.tipStr = "验证申请授权错误"; } var refundResult = new RefundService().SelectByID(OrderID); if (refundResult != null && refundResult.RefundStatus == (int)Order_Status.Refunding) { var RecordEntity = new RecordService().SelectByID(OrderID); ViewBag.OrderID = RecordEntity != null ? RecordEntity.RecordID : OrderID; ViewBag.OrderNo = RecordEntity != null ? RecordEntity.OrderNo : ""; ViewBag.Amount = RecordEntity != null ? RecordEntity.Amount : 0; ViewBag.Description = RecordEntity != null ? RecordEntity.Description : ""; ViewBag.RefundAmount = refundResult.Amount; ViewBag.RefundRemark = refundResult.Remark; ViewBag.tipStr = ""; } else { ViewBag.tipStr = "退款单已处理"; } return(View()); }
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 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 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("OrderList")); }
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 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 CancelOrder(int id) { // get order header OrderHeader orderHeader = _unitOfWork.OrderHeader.GetFirstOrDefault(u => u.Id == id); // if the order has been approved then it will need to be refunded if (orderHeader.PaymentStatus == SD.StatusApproved) { // create refund options 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); // set orderHeader properties in line with a refund orderHeader.OrderStatus = SD.StatusRefunded; orderHeader.PaymentStatus = SD.StatusRefunded; } else { // order was not approved so it will be cancelled orderHeader.OrderStatus = SD.StatusCancelled; orderHeader.PaymentStatus = SD.StatusCancelled; } _unitOfWork.Save(); return(RedirectToAction("Index")); }
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 async Task CancelAndRecoverChargesAsync(ISubscriber subscriber) { if (!string.IsNullOrWhiteSpace(subscriber.GatewaySubscriptionId)) { var subscriptionService = new SubscriptionService(); await subscriptionService.CancelAsync(subscriber.GatewaySubscriptionId, new SubscriptionCancelOptions()); } if (string.IsNullOrWhiteSpace(subscriber.GatewayCustomerId)) { return; } var customerService = new CustomerService(); var customer = await customerService.GetAsync(subscriber.GatewayCustomerId); if (customer == null) { return; } if (customer.Metadata.ContainsKey("btCustomerId")) { var transactionRequest = new Braintree.TransactionSearchRequest() .CustomerId.Is(customer.Metadata["btCustomerId"]); var transactions = _btGateway.Transaction.Search(transactionRequest); if ((transactions?.MaximumCount ?? 0) > 0) { var txs = transactions.Cast <Braintree.Transaction>().Where(c => c.RefundedTransactionId == null); foreach (var transaction in txs) { await _btGateway.Transaction.RefundAsync(transaction.Id); } } await _btGateway.Customer.DeleteAsync(customer.Metadata["btCustomerId"]); } else { var chargeService = new ChargeService(); var charges = await chargeService.ListAsync(new ChargeListOptions { CustomerId = subscriber.GatewayCustomerId }); if (charges?.Data != null) { var refundService = new RefundService(); foreach (var charge in charges.Data.Where(c => !c.Refunded)) { await refundService.CreateAsync(new RefundCreateOptions { ChargeId = charge.Id }); } } } await customerService.DeleteAsync(subscriber.GatewayCustomerId); }
public void TestNotify() { string _tmp = "1"; var ser = new RefundService(); ser.NotifyRefund("2015102253741655"); Assert.IsTrue(!string.IsNullOrWhiteSpace(_tmp)); }
private static async Task <ApiResult <ApiRefundResponse> > BecauseAsync() { var createPaymentResult = await _alternativePaymentService.CreatePaymentAsync(PaymentRequest); await Task.Delay(2000); return(await RefundService.CreateRefundAsync(createPaymentResult.Value.Payment.ID.Value, RefundRequest)); }
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 CoronaController( MemberContext database, UserManager <User> userManager, RefundService refundService) { _database = database; _userManager = userManager; _refundService = refundService; }
public void Connect(string apiUrl, string apiKey) { PaymillWrapper.Paymill.ApiKey = apiKey; PaymillWrapper.Paymill.ApiUrl = apiUrl; clientService = Paymill.GetService<ClientService>(); paymentService = Paymill.GetService<PaymentService>(); transactionService = Paymill.GetService<TransactionService>(); refundService = Paymill.GetService<RefundService>(); }
public async Task can_claim_refund() { uint timestamp = 1546871954; _bridge.NextBlockPlease(timestamp); DepositService depositService = new DepositService(_ndmBridge, _abiEncoder, _wallet, _contractAddress); Keccak assetId = Keccak.Compute("data asset"); uint expiryTime = timestamp + 4; UInt256 value = 1.Ether(); uint units = 10U; byte[] salt = new byte[16]; AbiSignature depositAbiDef = new AbiSignature("deposit", new AbiBytes(32), new AbiUInt(32), new AbiUInt(96), new AbiUInt(32), new AbiBytes(16), AbiType.Address, AbiType.Address); byte[] depositData = _abiEncoder.Encode(AbiEncodingStyle.Packed, depositAbiDef, assetId.Bytes, units, value, expiryTime, salt, _providerAccount, _consumerAccount); Keccak depositId = Keccak.Compute(depositData); Deposit deposit = new Deposit(depositId, units, expiryTime, value); Keccak depositTxHash = await depositService.MakeDepositAsync(_consumerAccount, deposit, 20.GWei()); _bridge.IncrementNonce(_consumerAccount); TxReceipt depositTxReceipt = _bridge.GetReceipt(depositTxHash); TestContext.WriteLine("GAS USED FOR DEPOSIT: {0}", depositTxReceipt.GasUsed); Assert.AreEqual(StatusCode.Success, depositTxReceipt.StatusCode, $"deposit made {depositTxReceipt.Error} {Encoding.UTF8.GetString(depositTxReceipt.ReturnValue ?? new byte[0])}"); // calls revert and cannot reuse the same state - use only for manual debugging // Assert.True(depositService.VerifyDeposit(deposit.Id), "deposit verified"); RefundService refundService = new RefundService(_ndmBridge, _abiEncoder, _depositRepository, _contractAddress, LimboLogs.Instance, _wallet); // it will not work so far as we do everything within the same block and timestamp is wrong _bridge.NextBlockPlease(expiryTime + 1); RefundClaim refundClaim = new RefundClaim(depositId, assetId, units, value, expiryTime, salt, _providerAccount, _consumerAccount); UInt256 balanceBefore = _state.GetBalance(_consumerAccount); Keccak refundTxHash = await refundService.ClaimRefundAsync(_consumerAccount, refundClaim, 20.GWei()); TxReceipt refundReceipt = _bridge.GetReceipt(refundTxHash); TestContext.WriteLine("GAS USED FOR REFUND CLAIM: {0}", refundReceipt.GasUsed); Assert.AreEqual(StatusCode.Success, refundReceipt.StatusCode, $"refund claim {refundReceipt.Error} {Encoding.UTF8.GetString(refundReceipt.ReturnValue ?? new byte[0])}"); UInt256 balanceAfter = _state.GetBalance(_consumerAccount); Assert.Greater(balanceAfter, balanceBefore); }
public async Task <Refund> CreateRefundAsync(string chargeId) { var options = new RefundCreateOptions { Charge = chargeId, }; var service = new RefundService(); return(await service.CreateAsync(options)); }
public async Task set_early_refund_ticket_should_fail_if_deposit_does_not_exits() { const RefundReason reason = RefundReason.DataDiscontinued; var ticket = new EarlyRefundTicket(TestItem.KeccakA, 0, null); var refundService = new RefundService(_ndmBridge, _abiEncoder, _depositRepository, _contractAddress, LimboLogs.Instance); await refundService.SetEarlyRefundTicketAsync(ticket, reason); await _depositRepository.Received().GetAsync(ticket.DepositId); await _depositRepository.DidNotReceiveWithAnyArgs().UpdateAsync(null); }
public StripeService(FurCoNZDbContext dbContext, IOptions <StripeSettings> options, IOrderService orderService, ILogger <StripeService> logger) { _dbContext = dbContext; _options = options; _orderService = orderService; _logger = logger; _paymentIntentService = new PaymentIntentService(); _checkoutService = new SessionService(); _chargeService = new ChargeService(); _refundService = new RefundService(); }
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))); }