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