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);
}
