/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
var result = new VoidPaymentResult();
result.AddError("Void method not supported");
return(result);
}
/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public async Task <VoidPaymentResult> Void(VoidPaymentRequest voidPaymentRequest)
{
var result = new VoidPaymentResult();
result.AddError("Void method not supported");
return(await Task.FromResult(result));
}
public VoidPaymentResponse Process(VoidPaymentRequest request)
{
Transaction tx = new Transaction();
tx.TestMode = request.Test;
tx.SetRequestParameter("VPSProtocol", "3.00");
tx.SetRequestParameter("TxType", "VOID");
tx.SetRequestParameter("Vendor", request.Vendor);
tx.SetRequestParameter("VendorTxCode", request.VendorTxCode);
tx.SetRequestParameter("VPSTxId", request.VPSTxId);
tx.SetRequestParameter("SecurityKey", request.SecurityKey);
tx.SetRequestParameter("TxAuthNo", request.TxAuthNo);
tx.SendVoid();
// Receive Response
var response = new VoidPaymentResponse();
response.VPSProtocol = tx.GetResponseParameter("VPSProtocol");
response.TxType = "VOID";
response.Status = tx.GetResponseParameter("Status");
response.StatusDetail = tx.GetResponseParameter("StatusDetail");
if (!String.IsNullOrEmpty(response.StatusDetail))
response.StatusDetail = response.StatusDetail.Replace("'", "`");
return response;
}
/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public override VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
var result = new VoidPaymentResult();
result.AddError(_localizationService.GetResource("Common.Payment.NoVoidSupport"));
return(result);
}
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
VoidPaymentResult voidPay = new VoidPaymentResult();
voidPay.AddError("Void method not supported.");
return(voidPay);
}
/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
var result = new VoidPaymentResult();
string transactionId = voidPaymentRequest.Order.AuthorizationTransactionId;
if (String.IsNullOrEmpty(transactionId))
{
transactionId = voidPaymentRequest.Order.CaptureTransactionId;
}
var req = new DoVoidReq();
req.DoVoidRequest = new DoVoidRequestType();
req.DoVoidRequest.Version = GetApiVersion();
req.DoVoidRequest.AuthorizationID = transactionId;
var service = GetService();
DoVoidResponseType response = service.DoVoid(req);
string error;
bool success = PaypalHelper.CheckSuccess(response, out error);
if (success)
{
result.NewPaymentStatus = PaymentStatus.Voided;
//result.VoidTransactionID = response.RefundTransactionID;
}
else
{
result.AddError(error);
}
return(result);
}
/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
var result = new VoidPaymentResult();
PrepareAuthorizeNet();
var maskedCreditCardNumberDecrypted = _encryptionService.DecryptText(voidPaymentRequest.Order.MaskedCreditCardNumber);
if (String.IsNullOrEmpty(maskedCreditCardNumberDecrypted) || maskedCreditCardNumberDecrypted.Length < 4)
{
result.AddError("Last four digits of Credit Card Not Available");
return(result);
}
var lastFourDigitsCardNumber = maskedCreditCardNumberDecrypted.Substring(maskedCreditCardNumberDecrypted.Length - 4);
var expirationDate = voidPaymentRequest.Order.CardExpirationMonth + voidPaymentRequest.Order.CardExpirationYear;
if (!expirationDate.Any())
{
expirationDate = "XXXX";
}
var creditCard = new creditCardType
{
cardNumber = lastFourDigitsCardNumber,
expirationDate = expirationDate
};
var codes = (string.IsNullOrEmpty(voidPaymentRequest.Order.CaptureTransactionId) ? voidPaymentRequest.Order.AuthorizationTransactionCode : voidPaymentRequest.Order.CaptureTransactionId).Split(',');
var transactionRequest = new transactionRequestType
{
transactionType = transactionTypeEnum.voidTransaction.ToString(),
refTransId = codes[0],
payment = new paymentType {
Item = creditCard
}
};
var request = new createTransactionRequest {
transactionRequest = transactionRequest
};
// instantiate the contoller that will call the service
var controller = new createTransactionController(request);
controller.Execute();
var response = GetApiResponse(controller, result.Errors);
//validate
if (response == null)
{
return(result);
}
result.NewPaymentStatus = PaymentStatus.Voided;
return(result);
}
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
return(new VoidPaymentResult {
Errors = new[] { "Void method not supported" }
});
//return description of this payment method to be display on "payment method" checkout step. good practice is to make it localizable
//for example, for a redirection payment method, description may be like this: "You will be redirected to site to complete the payment"
}
public void VoidPayment(VoidPaymentRequest request)
{
if (websocket != null)
{
VoidPaymentRequestMessage message = new VoidPaymentRequestMessage();
message.payload = request;
websocket.Send(JsonUtils.serialize(message));
}
}
/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
if (voidPaymentRequest == null)
{
throw new ArgumentException(nameof(voidPaymentRequest));
}
return(new VoidPaymentResult
{
NewPaymentStatus = PaymentStatus.Voided
});
}
public override VoidPaymentRequestResult VoidProcessPayment(VoidPaymentRequest request)
{
//TODO
//context.Payment.IsApproved = false;
//context.Payment.PaymentStatus = PaymentStatus.Voided;
//context.Payment.VoidedDate = DateTime.UtcNow;
//context.Payment.IsCancelled = true;
//context.Payment.CancelledDate = DateTime.UtcNow;
return(new VoidPaymentRequestResult {
IsSuccess = true, NewPaymentStatus = PaymentStatus.Voided
});
}
/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
var result = new VoidPaymentResult();
string transactionId = voidPaymentRequest.Order.AuthorizationTransactionId;
if (String.IsNullOrEmpty(transactionId))
{
transactionId = voidPaymentRequest.Order.CaptureTransactionId;
}
var req = new DoVoidReq();
req.DoVoidRequest = new DoVoidRequestType();
req.DoVoidRequest.Version = GetApiVersion();
req.DoVoidRequest.AuthorizationID = transactionId;
using (var service2 = new PayPalAPIAASoapBinding())
{
if (!_paypalDirectPaymentSettings.UseSandbox)
{
service2.Url = "https://api-3t.paypal.com/2.0/";
}
else
{
service2.Url = "https://api-3t.sandbox.paypal.com/2.0/";
}
service2.RequesterCredentials = new CustomSecurityHeaderType();
service2.RequesterCredentials.Credentials = new UserIdPasswordType();
service2.RequesterCredentials.Credentials.Username = _paypalDirectPaymentSettings.ApiAccountName;
service2.RequesterCredentials.Credentials.Password = _paypalDirectPaymentSettings.ApiAccountPassword;
service2.RequesterCredentials.Credentials.Signature = _paypalDirectPaymentSettings.Signature;
service2.RequesterCredentials.Credentials.Subject = "";
DoVoidResponseType response = service2.DoVoid(req);
string error = "";
bool success = PaypalHelper.CheckSuccess(response, out error);
if (success)
{
result.NewPaymentStatus = PaymentStatus.Voided;
//result.VoidTransactionID = response.RefundTransactionID;
}
else
{
result.AddError(error);
}
}
return(result);
}
/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
//var result = new VoidPaymentResult();
//PrepareAuthorizeNet();
//var maskedCreditCardNumberDecrypted = _encryptionService.DecryptText(voidPaymentRequest.Order.MaskedCreditCardNumber);
//if (String.IsNullOrEmpty(maskedCreditCardNumberDecrypted) || maskedCreditCardNumberDecrypted.Length < 4)
//{
// result.AddError("Last four digits of Credit Card Not Available");
// return result;
//}
//var lastFourDigitsCardNumber = maskedCreditCardNumberDecrypted.Substring(maskedCreditCardNumberDecrypted.Length - 4);
//var expirationDate = voidPaymentRequest.Order.CardExpirationMonth + voidPaymentRequest.Order.CardExpirationYear;
//if (!expirationDate.Any() && _authorizeNetPaymentSettings.UseSandbox)
// expirationDate = DateTime.Now.ToString("MMyyyy");
//var creditCard = new creditCardType
//{
// cardNumber = lastFourDigitsCardNumber,
// expirationDate = expirationDate
//};
//var codes = (string.IsNullOrEmpty(voidPaymentRequest.Order.CaptureTransactionId) ? voidPaymentRequest.Order.AuthorizationTransactionCode : voidPaymentRequest.Order.CaptureTransactionId).Split(',');
//var transactionRequest = new transactionRequestType
//{
// transactionType = transactionTypeEnum.voidTransaction.ToString(),
// refTransId = codes[0],
// payment = new paymentType { Item = creditCard }
//};
//var request = new createTransactionRequest { transactionRequest = transactionRequest };
//// instantiate the contoller that will call the service
//var controller = new createTransactionController(request);
//controller.Execute();
//// get the response from the service (errors contained if any)
//var response = controller.GetApiResponse();
////validate
//if (GetErrors(response, result.Errors))
// return result;
//result.NewPaymentStatus = PaymentStatus.Voided;
//return result;
throw new Exception("this method not implemented");
}
public void VoidPayment(HttpListenerContext context)
{
try
{
VoidPaymentRequest message = ParseRequest <VoidPaymentRequest>(context);
GetServer.CloverConnector.VoidPayment(message);
this.SendTextResponse(context, "");
}
catch (Exception e)
{
context.Response.StatusCode = 400;
context.Response.StatusDescription = e.Message;
this.SendTextResponse(context, "error processing request");
}
}
//////////////// Void methods /////////////
private void VoidButton_Click(object sender, EventArgs e)
{
VoidPaymentRequest request = new VoidPaymentRequest();
if (OrderPaymentsView.SelectedItems.Count == 1)
{
POSPayment payment = ((POSPayment)OrderPaymentsView.SelectedItems[0].Tag);
request.PaymentId = payment.PaymentID;
request.EmployeeId = payment.EmployeeID;
request.OrderId = payment.OrderID;
request.VoidReason = "USER_CANCEL";
cloverConnector.VoidPayment(request);
}
}
/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
var customSecurityHeaderType = _payPalSecurityService.GetRequesterCredentials();
using var payPalApiaaInterfaceClient = _payPalInterfaceService.GetAAService();
var response = payPalApiaaInterfaceClient.DoVoid(ref customSecurityHeaderType,
_payPalRequestService.GetVoidRequest(voidPaymentRequest));
return(response.HandleResponse(new VoidPaymentResult(),
(paymentResult, type) =>
paymentResult.NewPaymentStatus = PaymentStatus.Voided,
(paymentResult, type) =>
response.Errors.AddErrors(paymentResult.AddError),
voidPaymentRequest.Order.OrderGuid));
}
public static void testPaymentAndVoid(CloverConnector cloverConnector, TestConnectorListener connListener)
{
//BEGIN: Test Void
SaleRequest paymentRequest = new SaleRequest();
paymentRequest.ExternalId = ExternalIDUtil.GenerateRandomString(13);
paymentRequest.Amount = 1324;
paymentRequest.TipAmount = 123;
System.Console.WriteLine("Preparing To Test Sale: $" + paymentRequest.Amount * 100.00);
System.Console.WriteLine("Press Any Key to Continue...");
System.Console.ReadKey();
//cloverConnector.Sales += paymentListener;
cloverConnector.Sale(paymentRequest);
while (!connListener.hasResponse)
{
System.Console.WriteLine("Waiting for paymentResponse");
System.Threading.Thread.Sleep(1000);
}
SaleResponse response = connListener.saleResponse;
string paymentId = response.Payment.id;
string orderId = response.Payment.order.id;
string employeeId = response.Payment.employee.id;
VoidPaymentRequest voidRequest = new VoidPaymentRequest();
voidRequest.OrderId = orderId;
voidRequest.PaymentId = paymentId;
voidRequest.EmployeeId = employeeId;
voidRequest.VoidReason = VoidReason.USER_CANCEL.ToString();
cloverConnector.VoidPayment(voidRequest);
while (!connListener.hasResponse)
{
System.Console.WriteLine("Waiting for voidResponse");
System.Threading.Thread.Sleep(1000);
}
VoidPaymentResponse voidResponse = connListener.voidPaymentResponse;
System.Console.WriteLine(voidResponse.Result);
//END: Test Void
}
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
// Cancel Autorised Payment
VoidPaymentResult Vres = new VoidPaymentResult();
string lang = _workContext.WorkingLanguage.UniqueSeoCode;
string trID = voidPaymentRequest.Order.AuthorizationTransactionId;
Debug("start Void of:" + voidPaymentRequest.Order.OrderTotal.ToString());
// Void transaction
string url = _TbcPaymentSettings.ServiceURL;
string certPath = $@"{HttpContext.Current.Request.PhysicalApplicationPath}Plugins\Payments.TBCBankCard\KeyStore\{_TbcPaymentSettings.CertificatePath}";
Code.Merchant merchant = new Code.Merchant(certPath, _TbcPaymentSettings.SecretPass, url, 30000);
string res = "";
Code.CommandParams param = new Code.CommandParams(lang)
{
trans_id = trID, amount = voidPaymentRequest.Order.OrderTotal
};
try
{
res = merchant.SendReversal(param);
}
catch (Exception ex)
{
_logger.Error("TBC payment error - Reversal:" + ex.Message);
Vres.AddError("TBC Reversal error.");
return(Vres);
}
Code.StatusResult CheckResult = null;
CheckResult = new Code.StatusResult(res);
if (CheckResult.RESULT_CODE == "400")
{
// success
Vres.NewPaymentStatus = PaymentStatus.Voided;
}
else
{
_logger.Error("TBC Reversal failed: " + res);
Vres.AddError("Reversal failed: " + res);
}
return(Vres);
}
/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
var result = new VoidPaymentResult();
var voidResult = _sagePayServerWorkflowService.VoidTransaction(voidPaymentRequest.Order.OrderGuid.ToString());
if (!voidResult.Success)
{
result.AddError(voidResult.Message);
}
else
{
result.NewPaymentStatus = PaymentStatus.Voided;
}
return(result);
}
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
var result = new VoidPaymentResult();
var cardknoxFacade = PrepareCardknoxFacade();
var cardknoxRequest = new CardknoxSDK.Actions.Void.Request()
{
RefNum = voidPaymentRequest.Order.AuthorizationTransactionId
};
var response = cardknoxFacade.Void(cardknoxRequest)
.GetAwaiter().GetResult();
//validate
if (response == null)
{
return(result);
}
switch (response.ResponseType)
{
case CardknoxSDK.Infra.ResponseTypes.Accepted:
result.NewPaymentStatus = PaymentStatus.Voided;
break;
case CardknoxSDK.Infra.ResponseTypes.Declined:
result.AddError($"Payment void declined. Error code: {response.ErrorCode} - Error Message: {response.ErrorMessage}");
break;
case CardknoxSDK.Infra.ResponseTypes.Error:
result.AddError($"Payment void error. Error code: {response.ErrorCode} - Error Message: {response.ErrorMessage}");
break;
case CardknoxSDK.Infra.ResponseTypes.Timeout:
result.AddError($"Payment void timeout. Please try again. Error code: {response.ErrorCode} - Error Message: {response.ErrorMessage}");
break;
case CardknoxSDK.Infra.ResponseTypes.HttpException:
result.AddError($"Communication error. Please try again. Error code: {response.ErrorCode} - Error Message: {response.ErrorMessage}");
break;
}
return(result);
}
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
var result = new VoidPaymentResult();
try
{
_refundService.Create(voidPaymentRequest.Order.AuthorizationTransactionId);
result.NewPaymentStatus = PaymentStatus.Voided;
return(result);
}
catch (StripeException exception)
{
result.AddError(!string.IsNullOrEmpty(exception.StripeError.Code)
? $"{exception.StripeError.Message} Error code: {exception.StripeError.Code}"
: exception.StripeError.Message);
return(result);
}
}
/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
//void previously authorized payment
var(_, error) = _serviceManager.Void(_settings, voidPaymentRequest.Order.AuthorizationTransactionId);
if (!string.IsNullOrEmpty(error))
{
return new VoidPaymentResult {
Errors = new[] { error }
}
}
;
//request succeeded
return(new VoidPaymentResult {
NewPaymentStatus = PaymentStatus.Voided
});
}
/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
//void full amount of the authorized transaction
var(response, error) = _qualpayManager.VoidTransaction(voidPaymentRequest.Order.AuthorizationTransactionId);
if (!string.IsNullOrEmpty(error))
{
return new VoidPaymentResult {
Errors = new[] { error }
}
}
;
//request succeeded
return(new VoidPaymentResult {
NewPaymentStatus = PaymentStatus.Voided
});
}
public DoVoidReq GetVoidRequest(VoidPaymentRequest voidPaymentRequest)
{
var transactionId = voidPaymentRequest.Order.CaptureTransactionId;
if (string.IsNullOrEmpty(transactionId))
{
transactionId = voidPaymentRequest.Order.AuthorizationTransactionId;
}
return(new DoVoidReq
{
DoVoidRequest = new DoVoidRequestType
{
Version = GetVersion(),
AuthorizationID = transactionId,
MsgSubID = voidPaymentRequest.Order.Id + "-void"
}
});
}
public virtual async Task <IList <string> > VoidAsync(Order order)
{
Guard.NotNull(order, nameof(order));
if (!await CanVoidAsync(order))
{
throw new SmartException(T("Order.CannotVoid"));
}
VoidPaymentResult result = null;
try
{
var request = new VoidPaymentRequest
{
Order = order
};
result = await _paymentService.VoidAsync(request);
if (result.Success)
{
order.PaymentStatus = result.NewPaymentStatus;
order.AddOrderNote(T("Admin.OrderNotice.OrderVoided"));
// INFO: CheckOrderStatus performs commit.
await CheckOrderStatusAsync(order);
}
}
catch (Exception ex)
{
result ??= new();
result.Errors.Add(ex.ToAllMessages());
}
if (result.Errors.Any())
{
ProcessErrors(order, result.Errors, "Admin.OrderNotice.OrderVoidError");
await _db.SaveChangesAsync();
}
return(result.Errors);
}
/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public override VoidPaymentResult Void(VoidPaymentRequest request)
{
var result = new VoidPaymentResult()
{
NewPaymentStatus = request.Order.PaymentStatus
};
string transactionId = request.Order.AuthorizationTransactionId;
var settings = CommonServices.Settings.LoadSetting <TSetting>(request.Order.StoreId);
if (String.IsNullOrEmpty(transactionId))
{
transactionId = request.Order.CaptureTransactionId;
}
var req = new DoVoidReq();
req.DoVoidRequest = new DoVoidRequestType();
req.DoVoidRequest.Version = PayPalHelper.GetApiVersion();
req.DoVoidRequest.AuthorizationID = transactionId;
using (var service = new PayPalAPIAASoapBinding())
{
service.Url = PayPalHelper.GetPaypalServiceUrl(settings);
service.RequesterCredentials = PayPalHelper.GetPaypalApiCredentials(settings);
DoVoidResponseType response = service.DoVoid(req);
string error = "";
bool success = PayPalHelper.CheckSuccess(_helper, response, out error);
if (success)
{
result.NewPaymentStatus = PaymentStatus.Voided;
//result.VoidTransactionID = response.RefundTransactionID;
}
else
{
result.AddError(error);
}
}
return(result);
}
/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
var result = new VoidPaymentResult();
CheckoutCancelRequest outrequest = new CheckoutCancelRequest
{
checkout_id = voidPaymentRequest.Order.AuthorizationTransactionId,
cancel_reason = "Cancel payment for Order #" + voidPaymentRequest.Order.OrderGuid
};
WebClientResponse wcresponse = ProcessWebClient(outrequest);
foreach (string error in wcresponse.Errors)
{
result.AddError(error);
}
if (result.Errors.Count <= 0 && wcresponse.state == "cancelled")
{
result.NewPaymentStatus = PaymentStatus.Voided;
}
return(result);
}
/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public override VoidPaymentResult Void(VoidPaymentRequest request)
{
var result = new VoidPaymentResult
{
NewPaymentStatus = request.Order.PaymentStatus
};
var settings = Services.Settings.LoadSetting <TSetting>(request.Order.StoreId);
var transactionId = request.Order.AuthorizationTransactionId;
if (transactionId.IsEmpty())
{
transactionId = request.Order.CaptureTransactionId;
}
var req = new DoVoidReq();
req.DoVoidRequest = new DoVoidRequestType();
req.DoVoidRequest.Version = ApiVersion;
req.DoVoidRequest.AuthorizationID = transactionId;
using (var service = GetApiAaService(settings))
{
var response = service.DoVoid(req);
var error = "";
var success = IsSuccess(response, out error);
if (success)
{
result.NewPaymentStatus = PaymentStatus.Voided;
//result.VoidTransactionID = response.RefundTransactionID;
}
else
{
result.AddError(error);
}
}
return(result);
}
/// <summary>
/// Voids a payment
/// </summary>
/// <param name="voidPaymentRequest">Request</param>
/// <returns>Result</returns>
public VoidPaymentResult Void(VoidPaymentRequest voidPaymentRequest)
{
var result = new VoidPaymentResult();
var apiPayment = new Models.PaymentOrderMechantUpdate
{
apiId = _manualPaymentSettings.AppId,
merch_Id = _manualPaymentSettings.MerchantUniqueId,
merch_orderId = voidPaymentRequest.Order.OrderGuid.ToString(),
order_status = "CANCELLED"
};
using (var client = new HttpClient())
{
var content = new StringContent(JsonConvert.SerializeObject(apiPayment));
content.Headers.ContentType = new MediaTypeHeaderValue("application/json");
using (var res = client.PostAsync(String.Format("{0}api/v1/SecurePayment/UpdateOrder", _manualPaymentSettings.AppUrl), content))
{
res.Wait();
if (res.Result.IsSuccessStatusCode)
{
var data = res.Result.Content.ReadAsStringAsync();
var ret = JsonConvert.DeserializeObject <Models.ApiResponse>(data.Result.ToString());
switch (ret.responseCode.ToUpper())
{
case "APPROVED":
result.NewPaymentStatus = Core.Domain.Payments.PaymentStatus.Voided;
break;
default:
result.AddError(ret.responseText);
break;
}
}
else
{
result.AddError("Unable to process your request, Please try again later.");
}
}
}
return(result);
}
public static void Run()
{
ProcessPayment.CaptureTrueForProcessPayment = true;
var processPaymentId = ProcessPayment.Run().Id;
var clientReferenceInformationObj = new Ptsv2paymentsidreversalsClientReferenceInformation("test_payment_void");
var requestObj = new VoidPaymentRequest(clientReferenceInformationObj);
try
{
var configDictionary = new Configuration().GetConfiguration();
var clientConfig = new CyberSource.Client.Configuration(merchConfigDictObj: configDictionary);
var apiInstance = new VoidApi(clientConfig);
var result = apiInstance.VoidPayment(requestObj, processPaymentId);
Console.WriteLine(result);
}
catch (Exception e)
{
Console.WriteLine("Exception on calling the API: " + e.Message);
}
}
/// <summary>
/// Voids a payment and generates a new one.
/// </summary>
/// <param name="param">Parameters used to void the payment.</param>
/// <returns>The updated cart.</returns>
public virtual Task <Overture.ServiceModel.Orders.Cart> VoidPaymentAsync(VoidOrRemovePaymentParam param)
{
if (param == null)
{
throw new ArgumentNullException(nameof(param));
}
if (string.IsNullOrWhiteSpace(param.CartName))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(param.CartName)), nameof(param));
}
if (string.IsNullOrWhiteSpace(param.Scope))
{
throw new ArgumentException(GetMessageOfNullWhiteSpace(nameof(param.Scope)), nameof(param));
}
if (param.CultureInfo == null)
{
throw new ArgumentException(GetMessageOfNull(nameof(param.CultureInfo)), nameof(param));
}
if (param.CustomerId == Guid.Empty)
{
throw new ArgumentException(GetMessageOfEmpty(nameof(param.CustomerId)), nameof(param));
}
if (param.PaymentId == Guid.Empty)
{
throw new ArgumentException(GetMessageOfEmpty(nameof(param.PaymentId)), nameof(param));
}
var cacheKey = BuildCartCacheKey(param.Scope, param.CartName, param.CustomerId);
var request = new VoidPaymentRequest
{
CartName = param.CartName,
CultureName = param.CultureInfo.Name,
CustomerId = param.CustomerId,
PaymentId = param.PaymentId,
ScopeId = param.Scope
};
return(CacheProvider.ExecuteAndSetAsync(cacheKey, () => OvertureClient.SendAsync(request)));
}
public VoidPaymentResponse Void(VoidPaymentRequest voidPaymentRequest)
{
var paymentMethod = GetPaymentMethodByKey(voidPaymentRequest.Order.PaymentMethod);
return paymentMethod.Void(voidPaymentRequest);
}
public VoidPaymentResponse Void(VoidPaymentRequest voidPaymentRequest)
{
var result = new VoidPaymentResponse();
result.AddError("Void method not supported");
return result;
}
