private static void TestGetRefundInfo_Assert(RefundResponse refund, RefundResponse refundResponse)
{
Assert.AreEqual(refund.RefundId, refundResponse.RefundId, "Same refund id");
Assert.AreEqual(refund.Amount.ValueDecimal, refundResponse.Amount.ValueDecimal, "Same amount value");
Assert.AreEqual(refund.Amount.CurrencyEnum, refundResponse.Amount.CurrencyEnum, "Same currency value");
Assert.AreEqual(refund.StatusEnum, refundResponse.StatusEnum, "Same status");
}
internal static Response ConvertTo(RefundResponse refundResponse)
{
var response = new Response();
refundResponse.WriteBaseProperties(response);
var properties = new List <PaymentProperty>();
if (response.Properties != null)
{
properties.AddRange(response.Properties);
}
var refundRespnseProperties = new List <PaymentProperty>();
PaymentUtilities.AddPropertyIfPresent(refundRespnseProperties, GenericNamespace.RefundResponse, RefundResponseProperties.CardType, refundResponse.CardType);
PaymentUtilities.AddPropertyIfPresent(refundRespnseProperties, GenericNamespace.RefundResponse, RefundResponseProperties.Last4Digits, refundResponse.Last4Digit);
PaymentUtilities.AddPropertyIfPresent(refundRespnseProperties, GenericNamespace.RefundResponse, RefundResponseProperties.CardToken, refundResponse.CardToken);
PaymentUtilities.AddPropertyIfPresent(refundRespnseProperties, GenericNamespace.RefundResponse, RefundResponseProperties.UniqueCardId, refundResponse.UniqueCardId);
PaymentUtilities.AddPropertyIfPresent(refundRespnseProperties, GenericNamespace.RefundResponse, RefundResponseProperties.ProviderTransactionId, refundResponse.ProviderTransactionId);
PaymentUtilities.AddPropertyIfPresent(refundRespnseProperties, GenericNamespace.RefundResponse, RefundResponseProperties.ApprovalCode, refundResponse.ApprovalCode);
PaymentUtilities.AddPropertyIfPresent(refundRespnseProperties, GenericNamespace.RefundResponse, RefundResponseProperties.ResponseCode, refundResponse.ResponseCode);
PaymentUtilities.AddPropertyIfPresent(refundRespnseProperties, GenericNamespace.RefundResponse, RefundResponseProperties.ApprovedAmount, refundResponse.ApprovedAmount);
PaymentUtilities.AddPropertyIfPresent(refundRespnseProperties, GenericNamespace.RefundResponse, RefundResponseProperties.CurrencyCode, refundResponse.CurrencyCode);
PaymentUtilities.AddPropertyIfPresent(refundRespnseProperties, GenericNamespace.RefundResponse, RefundResponseProperties.RefundResult, refundResponse.RefundResult);
PaymentUtilities.AddPropertyIfPresent(refundRespnseProperties, GenericNamespace.RefundResponse, RefundResponseProperties.ProviderMessage, refundResponse.ProviderMessage);
PaymentUtilities.AddPropertyIfPresent(refundRespnseProperties, GenericNamespace.RefundResponse, RefundResponseProperties.TransactionType, refundResponse.TransactionType);
PaymentUtilities.AddPropertyIfPresent(refundRespnseProperties, GenericNamespace.RefundResponse, RefundResponseProperties.TransactionDateTime, refundResponse.TransactionDateTime);
properties.Add(new PaymentProperty(GenericNamespace.RefundResponse, RefundResponseProperties.Properties, refundRespnseProperties.ToArray()));
response.Properties = properties.ToArray();
return(response);
}
public RefundResponse CreateRefund(RefundRequest req)
{
var response = new RefundResponse();
try
{
using (var container = new TransactionModelContainer())
{
var refund = new Refund()
{
CreatedBy = req.CreateBy,
CreatedDate = DateTime.Now,
CustomerAddress = req.CustomerAddress,
CustomerIdmPartyId = req.CustomerIdmPartyId,
CustomerMobilePhoneNo = req.CustomerMobilePhoneNo,
CustomerName = req.CustomerName,
CustomerRefundAccountName = req.CustomerRefundAccountName,
CustomerRefundAccountNo = req.CustomerRefundAccountNo,
CustomerRefundBankId = req.CustomerRefundBankId,
IsVoid = req.IsVoid,
PaymentCode = req.PaymentCode,
Ref1 = req.Ref1,
Ref2 = req.Ref2,
Ref3 = req.Ref3,
Remark = req.Remark,
Status = req.Status,
UpdatedBy = req.UpdateBy,
UpdatedDate = DateTime.Now,
};
container.Refunds.AddObject(refund);
foreach (var r in req.Items)
{
var refundItem = new RefundItem()
{
GroupRef1 = r.GroupRef1,
GroupRef2 = r.GroupRef2,
ItemDescription = r.ItemDescription,
Qty = r.Qty,
Remark = r.Remark,
UnitAmount = r.UnitAmount,
};
container.RefundItems.AddObject(refundItem);
}
container.SaveChanges();
//response.SetPaymentResponse(payment);
response.Succeed();
}
}
catch (Exception ex)
{
response.Fail(ex);
CreateLog(ex);
}
return response;
}
public RefundResponse Refund(int operationID)
{
if (_configured)
{
try
{
RefundResponse response = new RefundResponse(TransbankWrap.refund(operationID));
if (response.Success)
{
return(response);
}
else
{
throw new TransbankRefundException("Refund returned an error: " + response.ResponseMessage, response);
}
}
catch (TransbankRefundException)
{
throw;
}
catch (Exception e)
{
throw new TransbankException("Unable to make Refund on POS", e);
}
}
else
{
throw new TransbankException("Port not Configured");
}
}
public RefundResponse PartialRefund(long paymentId, double amount)
{
RefundResponse refund = null;
PartialRefund partialRefund = new PartialRefund();
try
{
partialRefund.amount = Convert.ToInt64(amount * 100);
}
catch (Exception ex)
{
throw new ResponseException(ex.Message);
}
RestResponse result = this.restClient.Post(String.Format("payments/{0}/refunds", paymentId.ToString()), Model.PartialRefund.toJson(partialRefund));
if (result.StatusCode == STATUS_CREATED && !String.IsNullOrEmpty(result.Response))
{
refund = JsonConvert.DeserializeObject <RefundResponse>(result.Response);
}
else
{
if (isErrorResponse(result.StatusCode))
{
throw new ResponseException(result.StatusCode.ToString(), JsonConvert.DeserializeObject <ErrorResponse>(result.Response));
}
else
{
throw new ResponseException(result.StatusCode + " - " + result.Response);
}
}
return(refund);
}
/**
* AUTO_GENERATED
*/
public RefundResponse Refund(RefundRequest refundRequest, string apiUserName)
{
string response = Call("Refund", refundRequest.ToNVPString(""), apiUserName);
NVPUtil util = new NVPUtil();
return(RefundResponse.CreateInstance(util.ParseNVPString(response), "", -1));
}
public void TestRefundBill_Fake(
string amount = null,
string currency = null
)
{
// Prepare
foreach (var(client, presets) in _fakeDataRows)
{
PrepareRefund(
out var refundId,
out var moneyAmount,
amount,
currency
);
var refundResponse = new RefundResponse
{
Amount = moneyAmount,
DateTime = DateTime.Now,
RefundId = refundId,
StatusEnum = RefundStatusEnum.Partial
};
ResetClient(presets.Client, refundResponse);
// Test
presets.Client.OnRequest += TestRefundBill_OnRequest;
refundResponse = client.RefundBill(Config.BillIdForRefundTest, refundId, moneyAmount);
presets.Client.OnRequest -= TestRefundBill_OnRequest;
presets.Refunds.Add(refundResponse);
// Assert
TestRefundBill_Assert(refundId, moneyAmount, refundResponse);
}
}
public void AnulacionPartialRefundTest()
{
DecidirConnector decidir = new DecidirConnector(Ambiente.AMBIENTE_SANDBOX, "566f2c897b5e4bfaa0ec2452f5d67f13", "b192e4cb99564b84bf5db5550112adea");
CardData data = GetCardData();
PaymentResponse resultPaymentResponse = new PaymentResponse();
GetAllPaymentsResponse pagos = new GetAllPaymentsResponse();
RefundResponse refund = new RefundResponse();
DeleteRefundResponse deleteRefund = new DeleteRefundResponse();
try
{
Payment payment = GetPayment();
resultPaymentResponse = decidir.Payment(payment);
Assert.AreEqual(resultPaymentResponse.bin, payment.bin);
Assert.AreEqual(resultPaymentResponse.amount, payment.amount * 100);
Assert.AreEqual(resultPaymentResponse.site_transaction_id, payment.site_transaction_id);
//Wait for Refund
Thread.Sleep(5000);
refund = decidir.PartialRefund(resultPaymentResponse.id, 1000);
Assert.AreEqual(1000 * 100, refund.amount);
Assert.AreEqual("approved", refund.status);
deleteRefund = decidir.DeletePartialRefund(resultPaymentResponse.id, refund.id);
}
catch (Exception)
{
Assert.AreEqual(true, false);
}
}
public async void Example()
{
#pragma warning disable 0168
using (Client client = GetClient())
{
AmountOfMoney amountOfMoney = new AmountOfMoney();
amountOfMoney.Amount = 500L;
amountOfMoney.CurrencyCode = "EUR";
RefundReferences refundReferences = new RefundReferences();
refundReferences.MerchantReference = "AcmeOrder0001";
RefundRequest body = new RefundRequest();
body.AmountOfMoney = amountOfMoney;
body.RefundReferences = refundReferences;
try
{
RefundResponse response = await client.Merchant("merchantId").Captures().Refund("captureId", body);
}
catch (DeclinedRefundException e)
{
HandleDeclinedRefund(e.RefundResult);
}
catch (ApiException e)
{
HandleApiErrors(e.Errors);
}
}
#pragma warning restore 0168
}
public string RefundPayment(MetaDataViewDto metaData, PaymentViewDto payment, String refundAmount)
{
RefundRequestFactory refundRequestFactory = new RefundRequestFactory();
RefundRequest refundRequest = refundRequestFactory
.AddOriginalReferenceNumber(payment.PaymentReferenceNumber).AddAmount(refundAmount)
.AddClientIPAddress(metaData.ClientIPAddress).AddMsisdn(metaData.Msisdn).Build();
RestClientTool <RefundRequest, RefundResponse> restClient = new RestClientTool <RefundRequest, RefundResponse>();
RefundResponse refundResponse = restClient.RestClientRequest(Constants.REFUND_URL, refundRequest);
ResponseHeader responseHeader = refundResponse.ResponseHeader;
if (responseHeader.ResponseCode != null && responseHeader.ResponseCode == "0")
{
return(refundResponse.ApprovalCode);
}
else if (responseHeader.ResponseCode != null)
{
string errorMessage = "Refund payment was not successful: " + refundResponse.ResponseHeader.ResponseCode +
" " + refundResponse.ResponseHeader.ResponseDescription;
throw new Exception(errorMessage);
}
else
{
string errorMessage = "Refund payment was not successful, response status info is empty.";
throw new Exception(errorMessage);
}
}
public async Task <RefundResponse> RefundAsync(RefundRequest request)
{
SettleObject inputObj = new SortedDictionary <string, object>();
InitAlipayData(inputObj);
inputObj.SetValue("method", "alipay.trade.refund");
var bzContent = new
{
out_trade_no = request.OrderId,
refund_amount = request.RefundAmount / 100m,
refund_reason = request.Description,
out_request_no = request.RefundId
};
inputObj.SetValue("biz_content", JsonConvert.SerializeObject(bzContent));
inputObj.SetValue("sign", MakeSign(inputObj));
var result = await GetAsStringAsync($"{_options.Alipay.Gateway}?{inputObj.ToUrl()}");
var json = JObject.Parse(result);
var data = json.SelectToken("alipay_trade_refund_response").ToObject <IDictionary <string, object> >();
var sign = json.SelectToken("sign").ToObject <string>();
if (!CheckSign(JsonConvert.SerializeObject(data), sign))
{
throw new SettleException("支付宝退款验签失败");
}
var response = new RefundResponse
{
RefundId = request.RefundId
};
try
{
response.ProviderId = data["trade_no"]?.ToString();
response.Result = data["fund_change"]?.ToString() == "Y";
response.Message = $"{data["code"]}|{data["msg"]}";
if (data.ContainsKey("sub_code"))
{
response.Message += $"|{data["sub_code"]}";
}
if (data.ContainsKey("sub_msg"))
{
response.Message += $"|{data["sub_msg"]}";
}
}
catch (Exception)
{
response.Message = $"{data["code"]}|{data["msg"]}";
if (data.ContainsKey("sub_code"))
{
response.Message += $"|{data["sub_code"]}";
}
if (data.ContainsKey("sub_msg"))
{
response.Message += $"|{data["sub_msg"]}";
}
}
return(response);
}
private static void TestRefundBill_Assert(string refundId, MoneyAmount moneyAmount,
RefundResponse refundResponse)
{
Assert.AreEqual(refundId, refundResponse.RefundId, "Same refund id");
Assert.AreEqual(moneyAmount.ValueDecimal, refundResponse.Amount.ValueDecimal, "Same amount value");
Assert.AreEqual(moneyAmount.CurrencyEnum, refundResponse.Amount.CurrencyEnum, "Same currency value");
Assert.AreEqual(RefundStatusEnum.Partial, refundResponse.StatusEnum, "Status preset");
}
public ActionResult PartialRefund(int ambienteId, string privateApiKey, string publicApiKey, long paymentId, double amount)
{
DecidirConnector decidir = new DecidirConnector(ambienteId, privateApiKey, publicApiKey);
RefundResponse respuesta = decidir.PartialRefund(paymentId, amount);
return(Json(respuesta));
}
public ActionResult Refund(int ambienteId, string privateApiKey, string publicApiKey, long paymentId, string request_host, string request_path)
{
DecidirConnector decidir = GetDecidirConnector(ambienteId, privateApiKey, publicApiKey, request_host, request_path);
RefundResponse respuesta = decidir.Refund(paymentId);
return(Json(respuesta));
}
public RefundResponse Refund(RefundRequest request)
{
var response = new RefundResponse();
response.Success();
return(response);
}
public void Refund()
{
RefundSample sample = new RefundSample();
RefundResponse responseRefund = sample.RefundAPIOperation();
Assert.IsNotNull(responseRefund);
Assert.AreEqual(responseRefund.responseEnvelope.ack.ToString().ToUpper(), "SUCCESS");
}
public async void Example()
{
#pragma warning disable 0168
using (Client client = GetClient())
{
RefundResponse response = await client.Merchant("merchantId").Refunds().Get("refundId");
}
#pragma warning restore 0168
}
static string BuildMessage(RefundErrorResponse errorResponse)
{
RefundResponse refund = errorResponse?.RefundResult;
if (refund != null)
{
return("declined refund '" + refund.Id + "' with status '" + refund.Status + "'");
}
return("the payment platform returned a declined refund response");
}
public void RefundResponse()
{
var obj = new RefundResponse
{
Amount = 94,
CreatedAt = DateTime.Now,
Currency = "Lorum_738",
Details = new RefundDetailsResponse
{
CreditTransactionReference = "Lorum_819",
CreditTransactionStatus = "Lorum_245",
DebitTransactionReference = "Lorum_69",
DebitTransactionStatus = "Lorum_850",
PurchaseId = "Lorum_305",
RefundBic = "Lorum_982",
RefundIban = "Lorum_429",
RefundName = "Lorum_453"
},
PaymentId = "Lorum_289",
Reason = "Lorum_316",
RefundId = "Lorum_947",
Status = "Lorum_702",
Test = false,
UpdatedAt = DateTime.Now
};
var deserialized = ConversionTest(obj);
Assert.IsNotNull(deserialized);
Assert.AreEqual(obj.Amount, deserialized.Amount);
// Check only date and time up to seconds.. Json.NET does not save milliseconds.
Assert.AreEqual(
new DateTime(obj.CreatedAt.Year, obj.CreatedAt.Month, obj.CreatedAt.Day, obj.CreatedAt.Hour, obj.CreatedAt.Minute, obj.CreatedAt.Second),
new DateTime(deserialized.CreatedAt.Year, deserialized.CreatedAt.Month, deserialized.CreatedAt.Day, deserialized.CreatedAt.Hour, deserialized.CreatedAt.Minute, deserialized.CreatedAt.Second));
Assert.AreEqual(obj.Currency, deserialized.Currency);
Assert.AreEqual(obj.Details.CreditTransactionReference, deserialized.Details.CreditTransactionReference);
Assert.AreEqual(obj.Details.CreditTransactionStatus, deserialized.Details.CreditTransactionStatus);
Assert.AreEqual(obj.Details.DebitTransactionReference, deserialized.Details.DebitTransactionReference);
Assert.AreEqual(obj.Details.DebitTransactionStatus, deserialized.Details.DebitTransactionStatus);
Assert.AreEqual(obj.Details.PurchaseId, deserialized.Details.PurchaseId);
Assert.AreEqual(obj.Details.RefundBic, deserialized.Details.RefundBic);
Assert.AreEqual(obj.Details.RefundIban, deserialized.Details.RefundIban);
Assert.AreEqual(obj.Details.RefundName, deserialized.Details.RefundName);
Assert.AreEqual(obj.PaymentId, deserialized.PaymentId);
Assert.AreEqual(obj.Reason, deserialized.Reason);
Assert.AreEqual(obj.RefundId, deserialized.RefundId);
Assert.AreEqual(obj.Status, deserialized.Status);
Assert.AreEqual(obj.Test, deserialized.Test);
if (obj.UpdatedAt.HasValue && deserialized.UpdatedAt.HasValue)
{
// Check only date and time up to seconds.. Json.NET does not save milliseconds.
Assert.AreEqual(
new DateTime(obj.UpdatedAt.Value.Year, obj.UpdatedAt.Value.Month, obj.UpdatedAt.Value.Day, obj.UpdatedAt.Value.Hour, obj.UpdatedAt.Value.Minute, obj.UpdatedAt.Value.Second),
new DateTime(deserialized.UpdatedAt.Value.Year, deserialized.UpdatedAt.Value.Month, deserialized.UpdatedAt.Value.Day, deserialized.UpdatedAt.Value.Hour, deserialized.UpdatedAt.Value.Minute, deserialized.UpdatedAt.Value.Second));
}
}
public async void Example()
{
#pragma warning disable 0168
using (Client client = GetClient())
{
AmountOfMoney amountOfMoney = new AmountOfMoney();
amountOfMoney.Amount = 1L;
amountOfMoney.CurrencyCode = "EUR";
BankAccountIban bankAccountIban = new BankAccountIban();
bankAccountIban.Iban = "NL53INGB0000000036";
BankRefundMethodSpecificInput bankRefundMethodSpecificInput = new BankRefundMethodSpecificInput();
bankRefundMethodSpecificInput.BankAccountIban = bankAccountIban;
PersonalName name = new PersonalName();
name.Surname = "Coyote";
AddressPersonal address = new AddressPersonal();
address.CountryCode = "US";
address.Name = name;
ContactDetailsBase contactDetails = new ContactDetailsBase();
contactDetails.EmailAddress = "*****@*****.**";
contactDetails.EmailMessageType = "html";
RefundCustomer customer = new RefundCustomer();
customer.Address = address;
customer.ContactDetails = contactDetails;
RefundReferences refundReferences = new RefundReferences();
refundReferences.MerchantReference = "AcmeOrder0001";
RefundRequest body = new RefundRequest();
body.AmountOfMoney = amountOfMoney;
body.BankRefundMethodSpecificInput = bankRefundMethodSpecificInput;
body.Customer = customer;
body.RefundDate = "20140306";
body.RefundReferences = refundReferences;
try
{
RefundResponse response = await client.Merchant("merchantId").Payments().Refund("paymentId", body);
}
catch (DeclinedRefundException e)
{
HandleDeclinedRefund(e.RefundResult);
}
catch (ApiException e)
{
HandleApiErrors(e.Errors);
}
}
#pragma warning restore 0168
}
public void RefundCanBeMocked()
{
var refundResponse = new RefundResponse();
this.mockInStoreClient.Setup(mwsc => mwsc.Refund(It.IsAny <CreateRefundRequest>(), It.IsAny <Dictionary <string, string> >())).Returns(refundResponse);
var result = this.mockInStoreClient.Object.Refund(new CreateRefundRequest("ChargeId", 10, Types.Currency.USD, "RefundReferenceId"), new Dictionary <string, string>());
Assert.That(result, Is.EqualTo(refundResponse));
this.mockInStoreClient.Verify(mwsc => mwsc.Refund(It.IsAny <CreateRefundRequest>(), It.IsAny <Dictionary <string, string> >()), Times.Once);
}
public void GetRefundCanBeMocked()
{
var refundResponse = new RefundResponse();
this.mockWebStoreClient.Setup(mwsc => mwsc.GetRefund(It.IsAny <string>(), It.IsAny <Dictionary <string, string> >())).Returns(refundResponse);
var result = this.mockWebStoreClient.Object.GetRefund("RefundId", new Dictionary <string, string>());
Assert.That(result, Is.EqualTo(refundResponse));
this.mockWebStoreClient.Verify(mwsc => mwsc.GetRefund(It.IsAny <string>(), It.IsAny <Dictionary <string, string> >()), Times.Once);
}
public void RefundExampleTest()
{
string privateApiKey = "92b71cf711ca41f78362a7134f87ff65";
string publicApiKey = "e9cdb99fff374b5f91da4480c8dca741";
long paymentId = 0;
//Para el ambiente de desarrollo
DecidirConnector decidir = new DecidirConnector(Ambiente.AMBIENTE_SANDBOX, privateApiKey, publicApiKey);
RefundResponse refund = decidir.Refund(paymentId);
}
public dacRefund_Output Refund(ref SecurityHeaderType Security, RequestHeaderType RequestHeader, dacRefund_Input dacRefund_Input)
{
RefundRequest inValue = new RefundRequest();
inValue.Security = Security;
inValue.RequestHeader = RequestHeader;
inValue.dacRefund_Input = dacRefund_Input;
RefundResponse retVal = ((RefundV02)(this)).Refund(inValue);
Security = retVal.Security;
return(retVal.dacRefund_Output);
}
/// <summary>
///
/// </summary>
///<param name="refundRequest"></param>
///<param name="credential">An explicit ICredential object that you want to authenticate this call against</param>
public RefundResponse Refund(RefundRequest refundRequest, ICredential credential)
{
IAPICallPreHandler apiCallPreHandler = new PlatformAPICallPreHandler(this.config, refundRequest.ToNVPString(string.Empty), ServiceName, "Refund", credential);
((PlatformAPICallPreHandler)apiCallPreHandler).SDKName = SDKName;
((PlatformAPICallPreHandler)apiCallPreHandler).SDKVersion = SDKVersion;
((PlatformAPICallPreHandler)apiCallPreHandler).PortName = "AdaptivePayments";
NVPUtil util = new NVPUtil();
return(RefundResponse.CreateInstance(util.ParseNVPString(Call(apiCallPreHandler)), string.Empty, -1));
}
public static async Task <RefundResponse> RefundAsync(string bankTransactionID, decimal refundAmount, string refundRemarks, string referenceId = "")
{
if (string.IsNullOrEmpty(bankTransactionID))
{
throw new ArgumentException("BankTransactionID mustn't be empty", nameof(bankTransactionID));
}
if (refundAmount <= 0)
{
throw new ArgumentException("refundAmount must be greater than 0", nameof(refundAmount));
}
if (string.IsNullOrEmpty(refundRemarks))
{
throw new ArgumentException("RefundRemarks mustn't be empty", nameof(refundRemarks));
}
string requestUrl = Configuration.STORE_URL + "/validator/api/merchantTransIDvalidationAPI.php";
using (HttpClient client = new HttpClient())
{
Dictionary <string, string> parameters = new Dictionary <string, string>();
parameters.Add("bank_tran_id", bankTransactionID);
parameters.Add("store_id", Configuration.STORE_ID);
parameters.Add("store_passwd", Configuration.STORE_PASS);
parameters.Add("refund_amount", refundAmount.ToString());
parameters.Add("refund_remarks", refundRemarks);
if (!string.IsNullOrEmpty(referenceId))
{
parameters.Add("refe_id", referenceId);
}
parameters.Add("format", "json");
StringBuilder sb = new StringBuilder();
sb.Append(requestUrl + "?");
foreach (KeyValuePair <string, string> item in parameters)
{
sb.Append(item.Key + "=" + item.Value + "&");
}
requestUrl = sb.ToString().TrimEnd('&');
HttpResponseMessage response = await client.GetAsync(requestUrl);
response.EnsureSuccessStatusCode();
string responseString = await response.Content.ReadAsStringAsync();
RefundResponse refundResult = JsonConvert.DeserializeObject <RefundResponse>(responseString);
return(refundResult);
}
}
public async Task CanCreateRefund()
{
// If: We create a payment
PaymentResponse payment = await this.CreatePayment();
// We can only test this if you make the payment using the payment.Links.PaymentUrl property.
// If you don't do this, this test will fail because we can only refund payments that have been paid
Debugger.Break();
// When: We attempt to refund this payment
RefundResponse refundResponse = await fixture.RefundClient.CreateRefundAsync(payment.Id);
// Then
Assert.NotNull(refundResponse);
}
public async Task Create()
{
var response = new RefundResponse();
using (var api = new EbanxRefundOperationApi())
{
var request = new RefundRequest
{
Operation = "Cancel"
};
response = await api.Create(request);
}
Assert.IsFalse(response.Success);
}
private async Task ShouldRefundPayment_IdempotencyKey()
{
var refundResponse = new RefundResponse();
_apiClient.Setup(apiClient =>
apiClient.Post <RefundResponse>(PaymentsPath + "/payment_id/refunds", _authorization,
null,
CancellationToken.None, "test"))
.ReturnsAsync(() => refundResponse);
IPaymentsClient paymentsClient = new PaymentsClient(_apiClient.Object, _configuration.Object);
var response = await paymentsClient.RefundPayment("payment_id", null, "test");
response.ShouldNotBeNull();
}
public async Task <RefundResponse> IssueRefund(string returnOrderId, RefundRequest refundRequest)
{
// to avoid deadlock if this method is executed synchronously
await new ContextRemover();
Base.Http.Request request = CreateRequest();
request.EndpointUri = string.Format("/v3/returns/{0}/refund", returnOrderId);
request.AddPayload(GetSerializer().Serialize(refundRequest));
IResponse response = await client.PostAsync(request);
RefundResponse result = await ProcessResponse <RefundResponse>(response);
return(result);
}
public RefundResponse refund(RefundRequest req)
{
RefundResponse rsp = null;
try
{
var strResp = this.InternalRequest(req, "refund");
rsp = JsonConvert.DeserializeObject <RefundResponse>(strResp);
}
catch (JsonSerializationException e)
{
throw new Exception(e.Message);
}
return(rsp);
}
//Invoke the GetRefundDetails method
public GetRefundDetailsResponse GetRefundDetails(RefundResponse response)
{
return GetRefundDetailsSample.GetRefundDetails(this._service, this._propertiesCollection, response.RefundResult.RefundDetails.AmazonRefundId);
}
//Use a loop to check the status of the refund. Once the status is not "PENDING", it returns the response.
public GetRefundDetailsResponse CheckRefundStatus(RefundResponse refundResponse)
{
return RefundSample.CheckRefundStatus(refundResponse.RefundResult.RefundDetails.AmazonRefundId, this._service, this._propertiesCollection);
}
