private void Refund(Transaction t) { PayPalAPI ppAPI = this.GetPaypalAPI(); try { //per paypal's request, the refund type should always be set to partial string refundType = "Partial"; RefundTransactionResponseType refundResponse = ppAPI.RefundTransaction( t.PreviousTransactionNumber, refundType, String.Format("{0:N}", t.Amount)); if ((refundResponse.Ack == AckCodeType.Success) || (refundResponse.Ack == AckCodeType.SuccessWithWarning)) { t.Result.ReferenceNumber = refundResponse.RefundTransactionID; t.Result.Succeeded = true; } else { t.Result.Messages.Add(new Message("Paypal Payment Refund Failed.", "", MessageType.Warning)); foreach (ErrorType ppError in refundResponse.Errors) { t.Result.Messages.Add(new Message(ppError.LongMessage, ppError.ErrorCode, MessageType.Error)); } t.Result.Succeeded = false; } } finally { ppAPI = null; } }
public void RefundTransaction(string TransactionID) { RefundTransactionRequestType refundRequest = new RefundTransactionRequestType(); BasicAmountType amount = new BasicAmountType(); amount.currencyID = CurrencyCodeType.USD; refundRequest.Memo = "Transaction ID: " + TransactionID; refundRequest.RefundType = RefundPurposeTypeCodeType.Full; refundRequest.TransactionID = TransactionID; refundRequest.Version = "2.0"; RefundTransactionReq request = new RefundTransactionReq(); request.RefundTransactionRequest = refundRequest; try { RefundTransactionResponseType response = service.RefundTransaction(request); string errors = CheckForErrors(response); if (errors == string.Empty) { IsSubmissionSuccess = true; } else { IsSubmissionSuccess = false; SubmissionError = errors; } } catch (Exception ex) { throw ex; } }
/// <summary> /// Refunds payment /// </summary> /// <param name="order">Order</param> /// <param name="cancelPaymentResult">Cancel payment result</param> public void Refund(Order order, ref CancelPaymentResult cancelPaymentResult) { InitSettings(); string transactionID = cancelPaymentResult.CaptureTransactionId; RefundTransactionReq req = new RefundTransactionReq(); req.RefundTransactionRequest = new RefundTransactionRequestType(); //NOTE: Specify amount in partial refund req.RefundTransactionRequest.RefundType = RefundType.Full; req.RefundTransactionRequest.RefundTypeSpecified = true; req.RefundTransactionRequest.Version = this.APIVersion; req.RefundTransactionRequest.TransactionID = transactionID; RefundTransactionResponseType response = service1.RefundTransaction(req); string error = string.Empty; bool Success = PaypalHelper.CheckSuccess(response, out error); if (Success) { cancelPaymentResult.PaymentStatus = PaymentStatusEnum.Refunded; //cancelPaymentResult.RefundTransactionID = response.RefundTransactionID; } else { cancelPaymentResult.Error = error; } }
private void processResponse(PayPalAPIInterfaceServiceService service, RefundTransactionResponseType response) { HttpContext CurrContext = HttpContext.Current; CurrContext.Items.Add("Response_apiName", "RefundTransaction"); CurrContext.Items.Add("Response_redirectURL", null); CurrContext.Items.Add("Response_requestPayload", service.getLastRequest()); CurrContext.Items.Add("Response_responsePayload", service.getLastResponse()); Dictionary <string, string> keyParameters = new Dictionary <string, string>(); keyParameters.Add("Correlation Id", response.CorrelationID); keyParameters.Add("API Result", response.Ack.ToString()); if (response.Ack.Equals(AckCodeType.FAILURE) || (response.Errors != null && response.Errors.Count > 0)) { CurrContext.Items.Add("Response_error", response.Errors); } else { CurrContext.Items.Add("Response_error", null); keyParameters.Add("Refund transaction Id", response.RefundTransactionID); keyParameters.Add("Total refunded amount", response.TotalRefundedAmount.value + response.TotalRefundedAmount.currencyID); } CurrContext.Items.Add("Response_keyResponseObject", keyParameters); Server.Transfer("../APIResponse.aspx"); }
/// <summary> /// Handles refund /// </summary> /// <param name="request">RefundPaymentRequest</param> /// <returns>RefundPaymentResult</returns> public override RefundPaymentResult Refund(RefundPaymentRequest request) { var result = new RefundPaymentResult(); string transactionId = request.Order.CaptureTransactionId; var req = new RefundTransactionReq(); req.RefundTransactionRequest = new RefundTransactionRequestType(); //NOTE: Specify amount in partial refund req.RefundTransactionRequest.RefundType = RefundType.Full; req.RefundTransactionRequest.RefundTypeSpecified = true; req.RefundTransactionRequest.Version = PayPalHelper.GetApiVersion(); req.RefundTransactionRequest.TransactionID = transactionId; using (var service = new PayPalAPISoapBinding()) { service.Url = PayPalHelper.GetPaypalServiceUrl(Settings); service.RequesterCredentials = PayPalHelper.GetPaypalApiCredentials(Settings); RefundTransactionResponseType response = service.RefundTransaction(req); string error = string.Empty; bool Success = PayPalHelper.CheckSuccess(_helper, response, out error); if (Success) { result.NewPaymentStatus = PaymentStatus.Refunded; //cancelPaymentResult.RefundTransactionID = response.RefundTransactionID; } else { result.AddError(error); } } return(result); }
/// <summary> /// Refunds a payment /// </summary> /// <param name="refundPaymentRequest">Request</param> /// <returns>Result</returns> public RefundPaymentResult Refund(RefundPaymentRequest refundPaymentRequest) { var result = new RefundPaymentResult(); string transactionId = refundPaymentRequest.Order.CaptureTransactionId; var req = new RefundTransactionReq(); req.RefundTransactionRequest = new RefundTransactionRequestType(); //NOTE: Specify amount in partial refund req.RefundTransactionRequest.RefundType = RefundType.FULL; req.RefundTransactionRequest.Version = GetApiVersion(); req.RefundTransactionRequest.TransactionID = transactionId; var service = GetService(); RefundTransactionResponseType response = service.RefundTransaction(req); string error; bool success = PaypalHelper.CheckSuccess(response, out error); if (success) { result.NewPaymentStatus = PaymentStatus.Refunded; //cancelPaymentResult.RefundTransactionID = response.RefundTransactionID; } else { result.AddError(error); } return(result); }
public void RefundTransaction() { RefundTransactionSample sample = new RefundTransactionSample(); RefundTransactionResponseType responseRefundTransactionResponseType = sample.RefundTransactionAPIOperation(); Assert.IsNotNull(responseRefundTransactionResponseType); // Please change the sample inputs according to the documentation in the sample for the following assertion: // Assert.AreEqual(responseRefundTransactionResponseType.Ack.ToString().ToUpper(), "SUCCESS"); }
/// <summary> /// Refunds a payment /// </summary> /// <param name="refundPaymentRequest">Request</param> /// <returns>Result</returns> public RefundPaymentResult Refund(RefundPaymentRequest refundPaymentRequest) { var result = new RefundPaymentResult(); string transactionId = refundPaymentRequest.Order.CaptureTransactionId; var req = new RefundTransactionReq(); req.RefundTransactionRequest = new RefundTransactionRequestType { Version = GetApiVersion(), TransactionID = transactionId }; if (refundPaymentRequest.IsPartialRefund) { req.RefundTransactionRequest.RefundType = RefundType.PARTIAL; req.RefundTransactionRequest.Amount = new BasicAmountType { currencyID = PaypalHelper.GetPaypalCurrency(_currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId)), value = refundPaymentRequest.AmountToRefund.ToString() }; } else { req.RefundTransactionRequest.RefundType = RefundType.FULL; } var service = GetService(); RefundTransactionResponseType response = service.RefundTransaction(req); string error; bool success = PaypalHelper.CheckSuccess(response, out error); if (success) { result.NewPaymentStatus = (refundPaymentRequest.IsPartialRefund && refundPaymentRequest.Order.RefundedAmount + refundPaymentRequest.AmountToRefund < refundPaymentRequest.Order.OrderTotal) ? PaymentStatus.PartiallyRefunded : PaymentStatus.Refunded; //set refund transaction id for preventing refund twice _genericAttributeService.SaveAttribute(refundPaymentRequest.Order, "RefundTransactionId", response.RefundTransactionID); } else { result.AddError(error); } return(result); }
/// <summary> /// Refunds a payment /// </summary> /// <param name="refundPaymentRequest">Request</param> /// <returns>Result</returns> public RefundPaymentResult Refund(RefundPaymentRequest refundPaymentRequest) { var result = new RefundPaymentResult(); string transactionId = refundPaymentRequest.Order.CaptureTransactionId; var req = new RefundTransactionReq(); req.RefundTransactionRequest = new RefundTransactionRequestType(); //NOTE: Specify amount in partial refund req.RefundTransactionRequest.RefundType = RefundType.Full; req.RefundTransactionRequest.RefundTypeSpecified = true; req.RefundTransactionRequest.Version = GetApiVersion(); req.RefundTransactionRequest.TransactionID = transactionId; using (var service1 = new PayPalAPISoapBinding()) { if (!_paypalDirectPaymentSettings.UseSandbox) { service1.Url = "https://api-3t.paypal.com/2.0/"; } else { service1.Url = "https://api-3t.sandbox.paypal.com/2.0/"; } service1.RequesterCredentials = new CustomSecurityHeaderType(); service1.RequesterCredentials.Credentials = new UserIdPasswordType(); service1.RequesterCredentials.Credentials.Username = _paypalDirectPaymentSettings.ApiAccountName; service1.RequesterCredentials.Credentials.Password = _paypalDirectPaymentSettings.ApiAccountPassword; service1.RequesterCredentials.Credentials.Signature = _paypalDirectPaymentSettings.Signature; service1.RequesterCredentials.Credentials.Subject = ""; RefundTransactionResponseType response = service1.RefundTransaction(req); string error = string.Empty; bool Success = PaypalHelper.CheckSuccess(response, out error); if (Success) { result.NewPaymentStatus = PaymentStatus.Refunded; //cancelPaymentResult.RefundTransactionID = response.RefundTransactionID; } else { result.AddError(error); } } return(result); }
public string RefundTransaction(string TransactionID, bool DoFullRefund) { string sReturn = ""; // Create the Refund Request RefundTransactionRequestType refundRequest = new RefundTransactionRequestType(); BasicAmountType amount = new BasicAmountType(); CurrencyCodeType currType = (CurrencyCodeType)this._currencyCode; amount.currencyID = currType; if (DoFullRefund) { refundRequest.RefundType = RefundType.Full; } else { refundRequest.RefundType = RefundType.Partial; } refundRequest.TransactionID = TransactionID; refundRequest.Version = PayPalServiceUtility.PayPalAPIVersionNumber; RefundTransactionReq request = new RefundTransactionReq(); request.RefundTransactionRequest = refundRequest; try { RefundTransactionResponseType response = service.RefundTransaction(request); string ErrorCheck = CheckErrors(response); if (ErrorCheck != "") { sReturn = ErrorCheck; } else { sReturn = "Success"; } } catch (Exception x) { sReturn = "SSL Failure, the transaction did not go through. Error: " + x.Message; } return(sReturn); }
public string RefundTransaction(string TransactionID, decimal RefundAmount, string Memo, string currencyCode) { string sReturn = ""; CurrencyCodeType currType = (CurrencyCodeType)StringToEnum(typeof(CurrencyCodeType), currencyCode); // Create the Refund Request RefundTransactionRequestType refundRequest = new RefundTransactionRequestType(); BasicAmountType amount = new BasicAmountType(); amount.currencyID = currType; amount.Value = RefundAmount.ToString(); refundRequest.Memo = Memo; refundRequest.Amount = amount; refundRequest.RefundType = RefundType.Partial; refundRequest.TransactionID = TransactionID; refundRequest.Version = PayPalServiceUtility.PayPalAPIVersionNumber; RefundTransactionReq request = new RefundTransactionReq(); request.RefundTransactionRequest = refundRequest; try { RefundTransactionResponseType response = service.RefundTransaction(request); string ErrorCheck = CheckErrors(response); if (ErrorCheck != "") { sReturn = ("The transaction was not successful: " + ErrorCheck); } else { sReturn = ("Success"); } } catch (Exception x) { sReturn = "SSL Failure, the transaction did not go through. Error: " + x.Message; } return(sReturn); }
protected void Submit_Click(object sender, EventArgs e) { // Create request object RefundTransactionRequestType request = new RefundTransactionRequestType(); request.TransactionID = transactionId.Value; if (refundType.SelectedIndex != 0) { request.RefundType = (RefundType) Enum.Parse(typeof(RefundType), refundType.SelectedValue); if (request.RefundType.Equals(RefundType.PARTIAL) && refundAmount.Value != "") { CurrencyCodeType currency = (CurrencyCodeType) Enum.Parse(typeof(CurrencyCodeType), currencyCode.SelectedValue); request.Amount = new BasicAmountType(currency, refundAmount.Value); } } if (memo.Value != "") { request.Memo = memo.Value; } if (retryUntil.Text != "") { request.RetryUntil = retryUntil.Text; } if (refundSource.SelectedIndex != 0) { request.RefundSource = (RefundSourceCodeType) Enum.Parse(typeof(RefundSourceCodeType), refundSource.SelectedValue); } // Invoke the API RefundTransactionReq wrapper = new RefundTransactionReq(); wrapper.RefundTransactionRequest = request; PayPalAPIInterfaceServiceService service = new PayPalAPIInterfaceServiceService(); RefundTransactionResponseType refundTransactionResponse = service.RefundTransaction(wrapper); // Check for API return status processResponse(service, refundTransactionResponse); }
public IPaymentResult RefundPayment(IInvoice invoice, IPayment payment) { var transactionId = payment.ExtendedData.GetValue(Constants.ExtendedDataKeys.TransactionId); var wrapper = new RefundTransactionReq { RefundTransactionRequest = { TransactionID = transactionId, RefundType = RefundType.FULL } }; RefundTransactionResponseType refundTransactionResponse = GetPayPalService().RefundTransaction(wrapper); if (refundTransactionResponse.Ack != AckCodeType.SUCCESS && refundTransactionResponse.Ack != AckCodeType.SUCCESSWITHWARNING) { return(new PaymentResult(Attempt <IPayment> .Fail(payment), invoice, false)); } return(new PaymentResult(Attempt <IPayment> .Succeed(payment), invoice, true)); }
public bool Refund(MerchantTribe.Payment.Transaction t, MerchantTribeApplication app) { PayPalAPI ppAPI = Utilities.PaypalExpressUtilities.GetPaypalAPI(app.CurrentStore); try { if (t.PreviousTransactionNumber != null) { string refundType = string.Empty; //per paypal's request, the refund type should always be set to partial refundType = "Partial"; RefundTransactionResponseType refundResponse = ppAPI.RefundTransaction(t.PreviousTransactionNumber, refundType, string.Format("{0:N}", t.Amount)); if ((refundResponse.Ack == AckCodeType.Success) || (refundResponse.Ack == AckCodeType.SuccessWithWarning)) { t.Result.Succeeded = true; t.Result.Messages.Add(new MerchantTribe.Payment.Message("PayPal Express Payment Refunded Successfully.", "OK", MerchantTribe.Payment.MessageType.Information)); return(true); } else { t.Result.Succeeded = false; t.Result.Messages.Add(new MerchantTribe.Payment.Message("Paypal Express Payment Refund Failed.", "", MerchantTribe.Payment.MessageType.Error)); foreach (ErrorType ppError in refundResponse.Errors) { t.Result.Messages.Add(new MerchantTribe.Payment.Message(ppError.LongMessage, ppError.ErrorCode, MerchantTribe.Payment.MessageType.Error)); } return(false); } } } finally { ppAPI = null; } return(false); }
/// <summary> /// Credits the specified transaction. /// </summary> /// <param name="transaction">The transaction.</param> /// <param name="amount">The amount.</param> /// <param name="comment">The comment.</param> /// <param name="errorMessage">The error message.</param> /// <returns></returns> public override FinancialTransaction Credit(FinancialTransaction transaction, decimal amount, string comment, out string errorMessage) { errorMessage = string.Empty; if (transaction == null || string.IsNullOrWhiteSpace(transaction.TransactionCode) || transaction.FinancialGateway == null) { errorMessage = "Invalid original transaction, transaction code, or gateway."; return(null); } // Create the RefundTransactionResponseType object RefundTransactionResponseType responseRefundTransactionResponseType = new RefundTransactionResponseType(); try { // Create the RefundTransactionReq object RefundTransactionReq refundTransaction = new RefundTransactionReq(); RefundTransactionRequestType refundTransactionRequest = new RefundTransactionRequestType(); refundTransactionRequest.TransactionID = transaction.TransactionCode; refundTransactionRequest.RefundType = RefundType.FULL; // Set the amount refundTransactionRequest.Amount = new BasicAmountType(CurrencyCodeType.USD, amount.ToString()); refundTransaction.RefundTransactionRequest = refundTransactionRequest; // Create the service wrapper object to make the API call PayPalAPIInterfaceServiceService service = new PayPalAPIInterfaceServiceService(GetCredentials(transaction.FinancialGateway)); // # API call // Invoke the RefundTransaction method in service wrapper object responseRefundTransactionResponseType = service.RefundTransaction(refundTransaction); if (responseRefundTransactionResponseType != null) { // # Success values if (responseRefundTransactionResponseType.Ack.ToString().Trim().ToUpper().Equals("SUCCESS")) { var refundFinancialTransaction = new FinancialTransaction(); refundFinancialTransaction.TransactionCode = responseRefundTransactionResponseType.RefundTransactionID; return(refundFinancialTransaction); } // # Error Values else { List <ErrorType> errorMessages = responseRefundTransactionResponseType.Errors; foreach (ErrorType error in errorMessages) { errorMessage = string.Format("[{0}] {1}", responseRefundTransactionResponseType.Ack, error.LongMessage); } } } else { errorMessage = "Invalid transaction response from the financial gateway"; } } catch (System.Exception ex) { // Log the exception message errorMessage = ex.Message; } return(null); }
protected void Submit_Click(object sender, EventArgs e) { // Create request object RefundTransactionRequestType request = new RefundTransactionRequestType(); // (Required) Unique identifier of the transaction to be refunded. // Note: Either the transaction ID or the payer ID must be specified. request.TransactionID = transactionId.Value; // Type of refund you are making. It is one of the following values: // * Full – Full refund (default). // * Partial – Partial refund. // * ExternalDispute – External dispute. (Value available since version 82.0) // * Other – Other type of refund. (Value available since version 82.0) if (refundType.SelectedIndex != 0) { request.RefundType = (RefundType) Enum.Parse(typeof(RefundType), refundType.SelectedValue); // (Optional) Refund amount. The amount is required if RefundType is Partial. // Note: If RefundType is Full, do not set the amount. if (request.RefundType.Equals(RefundType.PARTIAL) && refundAmount.Value != string.Empty) { CurrencyCodeType currency = (CurrencyCodeType) Enum.Parse(typeof(CurrencyCodeType), currencyCode.SelectedValue); request.Amount = new BasicAmountType(currency, refundAmount.Value); } } // (Optional) Custom memo about the refund. if (memo.Value != string.Empty) { request.Memo = memo.Value; } // (Optional) Maximum time until you must retry the refund. if (retryUntil.Text != string.Empty) { request.RetryUntil = retryUntil.Text; } // (Optional)Type of PayPal funding source (balance or eCheck) that can be used for auto refund. It is one of the following values: // * any – The merchant does not have a preference. Use any available funding source. // * default – Use the merchant's preferred funding source, as configured in the merchant's profile. // * instant – Use the merchant's balance as the funding source. // * eCheck – The merchant prefers using the eCheck funding source. If the merchant's PayPal balance can cover the refund amount, use the PayPal balance. // Note: This field does not apply to point-of-sale transactions. if (refundSource.SelectedIndex != 0) { request.RefundSource = (RefundSourceCodeType) Enum.Parse(typeof(RefundSourceCodeType), refundSource.SelectedValue); } // Invoke the API RefundTransactionReq wrapper = new RefundTransactionReq(); wrapper.RefundTransactionRequest = request; // Configuration map containing signature credentials and other required configuration. // For a full list of configuration parameters refer in wiki page // [https://github.com/paypal/sdk-core-dotnet/wiki/SDK-Configuration-Parameters] Dictionary <string, string> configurationMap = Configuration.GetAcctAndConfig(); // Create the PayPalAPIInterfaceServiceService service object to make the API call PayPalAPIInterfaceServiceService service = new PayPalAPIInterfaceServiceService(configurationMap); // # API call // Invoke the RefundTransaction method in service wrapper object RefundTransactionResponseType refundTransactionResponse = service.RefundTransaction(wrapper); // Check for API return status processResponse(service, refundTransactionResponse); }
// # RefundTransaction API Operation // The RefundTransaction API operation issues a refund to the PayPal account holder associated with a transaction public RefundTransactionResponseType RefundTransactionAPIOperation() { // Create the RefundTransactionResponseType object RefundTransactionResponseType responseRefundTransactionResponseType = new RefundTransactionResponseType(); try { // Create the RefundTransactionReq object RefundTransactionReq refundTransaction = new RefundTransactionReq(); RefundTransactionRequestType refundTransactionRequest = new RefundTransactionRequestType(); // Either the `transaction ID` or the `payer ID` must be specified. // PayerID is unique encrypted merchant identification number // For setting `payerId`, // `refundTransactionRequest.PayerID = "A9BVYX8XCR9ZQ";` // Unique identifier of the transaction to be refunded. refundTransactionRequest.TransactionID = "1GF88795WC5643301"; // Type of refund you are making. It is one of the following values: // // * `Full` - Full refund (default). // * `Partial` - Partial refund. // * `ExternalDispute` - External dispute. (Value available since version // 82.0) // * `Other` - Other type of refund. (Value available since version 82.0) refundTransactionRequest.RefundType = RefundType.PARTIAL; // `Refund amount`, which contains // // * `Currency Code` // * `Amount` // The amount is required if RefundType is Partial. // `Note: // If RefundType is Full, do not set the amount.` BasicAmountType amount = new BasicAmountType(CurrencyCodeType.USD, "1.00"); refundTransactionRequest.Amount = amount; refundTransaction.RefundTransactionRequest = refundTransactionRequest; // Create the service wrapper object to make the API call PayPalAPIInterfaceServiceService service = new PayPalAPIInterfaceServiceService(); // # API call // Invoke the RefundTransaction method in service wrapper object responseRefundTransactionResponseType = service.RefundTransaction(refundTransaction); if (responseRefundTransactionResponseType != null) { // Response envelope acknowledgement string acknowledgement = "RefundTransaction API Operation - "; acknowledgement += responseRefundTransactionResponseType.Ack.ToString(); logger.Info(acknowledgement + "\n"); Console.WriteLine(acknowledgement + "\n"); // # Success values if (responseRefundTransactionResponseType.Ack.ToString().Trim().ToUpper().Equals("SUCCESS")) { // Unique transaction ID of the refund logger.Info("Refund Transaction ID : " + responseRefundTransactionResponseType.RefundTransactionID + "\n"); Console.WriteLine("Refund Transaction ID : " + responseRefundTransactionResponseType.RefundTransactionID + "\n"); } // # Error Values else { List <ErrorType> errorMessages = responseRefundTransactionResponseType.Errors; foreach (ErrorType error in errorMessages) { logger.Debug("API Error Message : " + error.LongMessage); Console.WriteLine("API Error Message : " + error.LongMessage + "\n"); } } } } // # Exception log catch (System.Exception ex) { // Log the exception message logger.Debug("Error Message : " + ex.Message); Console.WriteLine("Error Message : " + ex.Message); } return(responseRefundTransactionResponseType); }