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> /// 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 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; } }
public override RefundProcessPaymentResult RefundProcessPayment(RefundProcessPaymentEvaluationContext context) { if (context == null || context.Payment == null) { throw new ArgumentNullException("paymentEvaluationContext"); } RefundProcessPaymentResult retVal = new RefundProcessPaymentResult(); if (context.Payment.IsApproved && (context.Payment.PaymentStatus == PaymentStatus.Paid || context.Payment.PaymentStatus == PaymentStatus.Cancelled)) { try { var config = GetConfigMap(); var service = new PayPalAPIInterfaceServiceService(config); RefundTransactionReq refundTransctionRequest = GetRefundTransactionRequest(context.Payment); service.RefundTransaction(refundTransctionRequest); } catch (Exception ex) { retVal.ErrorMessage = ex.Message; } } return(new RefundProcessPaymentResult { ErrorMessage = "Not implemented yet" }); }
/// <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 RefundTransactionResponseType RefundTransaction(RefundTransactionReq RefundTransactionReq, string apiUsername) { setStandardParams(RefundTransactionReq.RefundTransactionRequest); string resp = call("RefundTransaction", RefundTransactionReq.toXMLString(), apiUsername); return(new RefundTransactionResponseType(resp)); }
/// <summary> /// Refunds or partially refunds a payment. /// </summary> /// <param name="invoice"> /// The invoice. /// </param> /// <param name="payment"> /// The payment. /// </param> /// <param name="amount"> /// The amount of the refund. /// </param> /// <returns> /// The <see cref="PayPalExpressTransactionRecord"/>. /// </returns> public ExpressCheckoutResponse Refund(IInvoice invoice, IPayment payment, decimal amount) { var record = payment.GetPayPalTransactionRecord(); // Ensure the currency code if (record.Data.CurrencyCode.IsNullOrWhiteSpace()) { var ex = new PayPalApiException("CurrencyCode was not found in payment extended data PayPal transaction data record. Cannot perform refund."); return(_responseFactory.Build(ex)); } // Ensure the transaction id if (record.Data.CaptureTransactionId.IsNullOrWhiteSpace()) { var ex = new PayPalApiException("CaptureTransactionId was not found in payment extended data PayPal transaction data record. Cannot perform refund."); return(_responseFactory.Build(ex)); } // Get the decimal configuration for the current currency var currencyCodeType = PayPalApiHelper.GetPayPalCurrencyCode(record.Data.CurrencyCode); var basicAmountFactory = new PayPalBasicAmountTypeFactory(currencyCodeType); ExpressCheckoutResponse result = null; if (amount > payment.Amount) { amount = payment.Amount; } try { var request = new RefundTransactionRequestType { InvoiceID = invoice.PrefixedInvoiceNumber(), PayerID = record.Data.PayerId, RefundSource = RefundSourceCodeType.DEFAULT, Version = record.DoCapture.Version, TransactionID = record.Data.CaptureTransactionId, Amount = basicAmountFactory.Build(amount) }; var wrapper = new RefundTransactionReq { RefundTransactionRequest = request }; var refundTransactionResponse = GetPayPalService().RefundTransaction(wrapper); result = _responseFactory.Build(refundTransactionResponse, record.Data.Token); } catch (Exception ex) { result = _responseFactory.Build(ex); } return(result); }
private RefundTransactionReq GetRefundTransactionRequest(PaymentIn payment) { var retVal = new RefundTransactionReq(); retVal.RefundTransactionRequest = new RefundTransactionRequestType(); retVal.RefundTransactionRequest.TransactionID = payment.OuterId; //retVal.RefundTransactionRequest.Amount return(retVal); }
/** * AUTO_GENERATED */ public RefundTransactionResponseType RefundTransaction(RefundTransactionReq refundTransactionReq, string apiUserName) { setStandardParams(refundTransactionReq.RefundTransactionRequest); string response = Call("RefundTransaction", refundTransactionReq.ToXMLString(), apiUserName); XmlDocument xmlDocument = new XmlDocument(); xmlDocument.LoadXml(response); XmlNode xmlNode = xmlDocument.SelectSingleNode("*[local-name()='Envelope']/*[local-name()='Body']/*[local-name()='RefundTransactionResponse']"); return(new RefundTransactionResponseType(xmlNode)); }
/// <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); }
/// <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); }
public ITransactionRefundResult Refund(ITransactionRefundRequest request) { //to refund a transaction, we'll need capture id previously obtained from paypal var captureId = request.GetParameterAs <string>(PaymentParameterNames.CaptureId); var paypalCurrency = PayPalHelper.GetPaypalCurrency(request.CurrencyIsoCode); //create a capture request for paypal var doRefundRequest = new RefundTransactionReq() { RefundTransactionRequest = new RefundTransactionRequestType() { Version = ApiVersion, TransactionID = captureId, Amount = new BasicAmountType() { value = Math.Round(request.Amount, 2).ToString("N", new CultureInfo("en-us")), currencyID = paypalCurrency }, RefundType = request.IsPartialRefund ? RefundType.PARTIAL : RefundType.FULL } }; //get the service for paypal api var service = GetPayPalApiInterfaceServiceService(); var paypalResponse = service.RefundTransaction(doRefundRequest); var result = new TransactionResult(); string error; var success = PayPalHelper.ParseResponseSuccess(paypalResponse, out error); if (success) { result.Success = true; result.SetParameter(PaymentParameterNames.RefundId, paypalResponse.RefundTransactionID); result.SetParameter(PaymentParameterNames.RefundResult, paypalResponse.Ack); } else { result.SetParameter(PaymentParameterNames.ErrorMessage, 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 override RefundPaymentResult Refund(RefundPaymentRequest request) { // "Transaction refused (10009). You can not refund this type of transaction.": // merchant must accept the payment in his PayPal account var result = new RefundPaymentResult { NewPaymentStatus = request.Order.PaymentStatus }; var settings = Services.Settings.LoadSetting <TSetting>(request.Order.StoreId); var transactionId = request.Order.CaptureTransactionId; var req = new RefundTransactionReq(); req.RefundTransactionRequest = new RefundTransactionRequestType(); if (request.IsPartialRefund) { var store = Services.StoreService.GetStoreById(request.Order.StoreId); var currencyCode = store.PrimaryStoreCurrency.CurrencyCode; req.RefundTransactionRequest.RefundType = RefundType.Partial; req.RefundTransactionRequest.Amount = new BasicAmountType(); req.RefundTransactionRequest.Amount.Value = Math.Round(request.AmountToRefund, 2).ToString("N", new CultureInfo("en-us")); req.RefundTransactionRequest.Amount.currencyID = (CurrencyCodeType)Enum.Parse(typeof(CurrencyCodeType), currencyCode, true); // see https://developer.paypal.com/docs/classic/express-checkout/digital-goods/ECDGIssuingRefunds/ // https://developer.paypal.com/docs/classic/api/merchant/RefundTransaction_API_Operation_NVP/ var memo = Services.Localization.GetResource("Plugins.cloudCommerce.PayPal.PartialRefundMemo", 0, false, "", true); if (memo.HasValue()) { req.RefundTransactionRequest.Memo = memo.FormatInvariant(req.RefundTransactionRequest.Amount.Value); } } else { req.RefundTransactionRequest.RefundType = RefundType.Full; } req.RefundTransactionRequest.RefundTypeSpecified = true; req.RefundTransactionRequest.Version = ApiVersion; req.RefundTransactionRequest.TransactionID = transactionId; using (var service = GetApiService(settings)) { var response = service.RefundTransaction(req); var error = ""; var Success = IsSuccess(response, out error); if (Success) { if (request.IsPartialRefund) { result.NewPaymentStatus = PaymentStatus.PartiallyRefunded; } else { result.NewPaymentStatus = PaymentStatus.Refunded; } //cancelPaymentResult.RefundTransactionID = response.RefundTransactionID; } else { result.AddError(error); } } return(result); }
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); }
/// <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); }
/// <summary> /// Refunds or partially refunds a payment. /// </summary> /// <param name="invoice"> /// The invoice. /// </param> /// <param name="payment"> /// The payment. /// </param> /// <param name="amount"> /// The amount of the refund. /// </param> /// <returns> /// The <see cref="PayPalExpressTransactionRecord"/>. /// </returns> public ExpressCheckoutResponse Refund(IInvoice invoice, IPayment payment, decimal amount) { var record = payment.GetPayPalTransactionRecord(); // Ensure the currency code if (record.Data.CurrencyCode.IsNullOrWhiteSpace()) { var ex = new PayPalApiException("CurrencyCode was not found in payment extended data PayPal transaction data record. Cannot perform refund."); return _responseFactory.Build(ex); } // Ensure the transaction id if (record.Data.CaptureTransactionId.IsNullOrWhiteSpace()) { var ex = new PayPalApiException("CaptureTransactionId was not found in payment extended data PayPal transaction data record. Cannot perform refund."); return _responseFactory.Build(ex); } // Get the decimal configuration for the current currency var currencyCodeType = PayPalApiHelper.GetPayPalCurrencyCode(record.Data.CurrencyCode); var basicAmountFactory = new PayPalBasicAmountTypeFactory(currencyCodeType); ExpressCheckoutResponse result = null; if (amount > payment.Amount) amount = payment.Amount; try { var request = new RefundTransactionRequestType { InvoiceID = invoice.PrefixedInvoiceNumber(), PayerID = record.Data.PayerId, RefundSource = RefundSourceCodeType.DEFAULT, Version = record.DoCapture.Version, TransactionID = record.Data.CaptureTransactionId, Amount = basicAmountFactory.Build(amount) }; var wrapper = new RefundTransactionReq { RefundTransactionRequest = request }; var refundTransactionResponse = GetPayPalService().RefundTransaction(wrapper); result = _responseFactory.Build(refundTransactionResponse, record.Data.Token); } catch (Exception ex) { result = _responseFactory.Build(ex); } return result; }
// # 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); }
/// <remarks/> public void RefundTransactionAsync(RefundTransactionReq RefundTransactionReq) { this.RefundTransactionAsync(RefundTransactionReq, null); }
/// <remarks/> public void RefundTransactionAsync(RefundTransactionReq RefundTransactionReq, object userState) { if ((this.RefundTransactionOperationCompleted == null)) { this.RefundTransactionOperationCompleted = new System.Threading.SendOrPostCallback(this.OnRefundTransactionOperationCompleted); } this.InvokeAsync("RefundTransaction", new object[] { RefundTransactionReq}, this.RefundTransactionOperationCompleted, userState); }
// if RefundAmount == 0.0M, then then ENTIRE order amount will be refunded! public override string RefundOrder(int OriginalOrderNumber, int NewOrderNumber, decimal RefundAmount, String RefundReason, Address UseBillingAddress) { String result = String.Empty; DB.ExecuteSQL("update orders set RefundTXCommand=NULL, RefundTXResult=NULL where OrderNumber=" + OriginalOrderNumber.ToString()); String TransID = String.Empty; Decimal OrderTotal = System.Decimal.Zero; using (var con = new SqlConnection(DB.GetDBConn())) { con.Open(); using (var rs = DB.GetRS("select * from Orders with (NOLOCK) where OrderNumber=" + OriginalOrderNumber.ToString(), con)) { if (rs.Read()) { TransID = Regex.Match(DB.RSField(rs, "AuthorizationPNREF"), "(?<=CAPTURE=)[0-9A-Z]+", RegexOptions.Compiled).ToString(); OrderTotal = DB.RSFieldDecimal(rs, "OrderTotal"); } } } if (TransID.Length == 0 || TransID == "0") { result = "Invalid or Empty Transaction ID"; } else { try { RefundTransactionReq RefundReq = new RefundTransactionReq(); RefundTransactionRequestType RefundRequestType = new RefundTransactionRequestType(); RefundTransactionResponseType RefundResponse; BasicAmountType BasicAmount = new BasicAmountType(); RefundRequestType.TransactionID = TransID; RefundRequestType.Version = API_VER; BasicAmount.currencyID = (CurrencyCodeType)Enum.Parse(typeof(CurrencyCodeType), AppLogic.AppConfig("Localization.StoreCurrency"), true); //If partial refund set value ( like 1.95). If FULL Refund leave it empty. The transactionID will take care of the amount if (OrderTotal == RefundAmount || RefundAmount == 0.0M) { RefundRequestType.RefundType = RefundType.Full; } else { BasicAmount.Value = Localization.CurrencyStringForGatewayWithoutExchangeRate(RefundAmount); RefundRequestType.RefundType = RefundType.Partial; } RefundRequestType.Amount = BasicAmount; RefundRequestType.RefundTypeSpecified = true; if (!String.IsNullOrEmpty(RefundReason)) { RefundRequestType.Memo = RefundReason; } RefundReq.RefundTransactionRequest = RefundRequestType; DB.ExecuteSQL("update orders set RefundTXCommand=" + DB.SQuote(XmlCommon.SerializeObject(RefundRequestType, RefundRequestType.GetType())) + " where OrderNumber=" + OriginalOrderNumber.ToString()); RefundResponse = (RefundTransactionResponseType)IPayPalRefund.RefundTransaction(RefundReq); //if (LogToErrorTable) //{ // PayPalController.Log(XmlCommon.SerializeObject(RefundReq, RefundReq.GetType()), "RefundTransaction Request"); // PayPalController.Log(XmlCommon.SerializeObject(RefundResponse, RefundResponse.GetType()), "RefundTransaction Response"); //} DB.ExecuteSQL("update orders set RefundTXCommand=" + DB.SQuote(XmlCommon.SerializeObject(RefundReq, RefundReq.GetType())) + ", RefundTXResult=" + DB.SQuote(XmlCommon.SerializeObject(RefundResponse, RefundResponse.GetType())) + " where OrderNumber=" + OriginalOrderNumber.ToString()); String RefundTXResult = String.Empty; if (RefundResponse != null && RefundResponse.Ack.ToString().StartsWith("success", StringComparison.InvariantCultureIgnoreCase)) { result = AppLogic.ro_OK; String RefundTransID = RefundResponse.RefundTransactionID; DB.ExecuteSQL("update orders set AuthorizationPNREF=AuthorizationPNREF+'|REFUND=" + RefundTransID + "' where OrderNumber=" + OriginalOrderNumber.ToString()); } else { if (RefundResponse.Errors != null) { bool first = true; for (int ix = 0; ix < RefundResponse.Errors.Length; ix++) { if (!first) { result += ", "; } result += "Error: [" + RefundResponse.Errors[ix].ErrorCode + "] " + RefundResponse.Errors[ix].LongMessage; first = false; } result += "Note: If you are using Accelerated Boarding for PayPal Express you will not be able to modify orders until you sign up for a full account and enter your API credentials."; } } } catch { result = "NO RESPONSE FROM GATEWAY!"; } } return(result); }
public RefundTransactionResponseType RefundTransaction(RefundTransactionReq RefundTransactionReq) { return(RefundTransaction(RefundTransactionReq, null)); }