public async Task CanGetPaymentShipping()
{
PaymentRequest <CardSource> paymentRequest = TestHelper.CreateCardPaymentRequest();
paymentRequest.Shipping = new ShippingDetails()
{
Address = new Address()
{
AddressLine1 = "221B Baker Street", AddressLine2 = null, City = "London", Country = "UK", State = "n/a", Zip = "NW1 6XE"
},
Phone = new Phone()
{
CountryCode = "44", Number = "124312431243"
}
};
PaymentResponse paymentResponse = await _api.Payments.RequestAsync(paymentRequest);
GetPaymentResponse paymentDetails = await _api.Payments.GetAsync(paymentResponse.Payment.Id);
paymentDetails.Shipping.ShouldNotBeNull();
paymentDetails.Shipping.Address.ShouldNotBeNull();
paymentDetails.Shipping.Address.AddressLine1.ShouldBe(paymentRequest.Shipping.Address.AddressLine1);
paymentDetails.Shipping.Address.AddressLine2.ShouldBe(paymentRequest.Shipping.Address.AddressLine2);
paymentDetails.Shipping.Address.City.ShouldBe(paymentRequest.Shipping.Address.City);
paymentDetails.Shipping.Address.Country.ShouldBe(paymentRequest.Shipping.Address.Country);
paymentDetails.Shipping.Address.State.ShouldBe(paymentRequest.Shipping.Address.State);
paymentDetails.Shipping.Address.Zip.ShouldBe(paymentRequest.Shipping.Address.Zip);
paymentDetails.Shipping.Phone.CountryCode.ShouldBe(paymentRequest.Shipping.Phone.CountryCode);
paymentDetails.Shipping.Phone.Number.ShouldBe(paymentRequest.Shipping.Phone.Number);
}
public async Task CanGetThreeDsPaymentBeforeAuth()
{
PaymentRequest <CardSource> paymentRequest = TestHelper.CreateCardPaymentRequest();
paymentRequest.ThreeDS = true;
PaymentResponse paymentResponse = await _api.Payments.RequestAsync(paymentRequest);
paymentResponse.IsPending.ShouldBe(true);
GetPaymentResponse paymentDetails = await _api.Payments.GetAsync(paymentResponse.Pending.Id);
paymentDetails.ShouldNotBeNull();
paymentDetails.Id.ShouldBe(paymentResponse.Pending.Id);
paymentDetails.Customer.ShouldNotBeNull();
paymentDetails.Customer.Id.ShouldBe(paymentResponse.Pending.Customer.Id);
paymentDetails.Customer.Email.ShouldBe(paymentRequest.Customer.Email);
paymentDetails.Amount.ShouldBe(paymentRequest.Amount);
paymentDetails.Currency.ShouldBe(paymentRequest.Currency);
paymentDetails.Reference.ShouldNotBeNullOrWhiteSpace();
paymentDetails.PaymentType.ShouldBe(PaymentType.Regular);
paymentDetails.Risk.ShouldNotBeNull();
paymentDetails.RequestedOn.ShouldBeGreaterThan(DateTime.MinValue);
paymentDetails.ThreeDS.ShouldNotBeNull();
paymentDetails.ThreeDS.Downgraded.ShouldBe(false);
paymentDetails.ThreeDS.Enrolled.ShouldNotBeNullOrEmpty();
paymentDetails.RequiresRedirect().ShouldBe(true);
paymentDetails.GetRedirectLink().ShouldNotBeNull();
paymentDetails.Links.ShouldNotBeNull();
paymentDetails.Links.ShouldNotBeEmpty();
paymentDetails.Status.ShouldBe(PaymentStatus.Pending);
paymentDetails.Source.AsCard().ShouldNotBeNull();
paymentDetails.Approved.ShouldBeFalse();
}
public async Task CanGetNonThreeDsPayment()
{
PaymentRequest <CardSource> paymentRequest = TestHelper.CreateCardPaymentRequest();
paymentRequest.PaymentType = PaymentType.Recurring;
PaymentResponse paymentResponse = await _api.Payments.RequestAsync(paymentRequest);
GetPaymentResponse paymentDetails = await _api.Payments.GetAsync(paymentResponse.Payment.Id);
paymentDetails.ShouldNotBeNull();
paymentDetails.Id.ShouldBe(paymentResponse.Payment.Id);
paymentDetails.Customer.ShouldNotBeNull();
paymentDetails.Customer.Id.ShouldBe(paymentResponse.Payment.Customer.Id);
paymentDetails.Customer.Email.ShouldBe(paymentRequest.Customer.Email);
paymentDetails.Amount.ShouldBe(paymentResponse.Payment.Amount);
paymentDetails.Currency.ShouldBe(paymentResponse.Payment.Currency);
paymentDetails.PaymentType.ShouldBe(paymentRequest.PaymentType);
paymentDetails.BillingDescriptor.ShouldNotBeNull();
paymentDetails.Reference.ShouldNotBeNullOrWhiteSpace();
paymentDetails.Risk.ShouldNotBeNull();
paymentDetails.RequestedOn.ShouldBeGreaterThan(paymentResponse.Payment.ProcessedOn.AddMinutes(-1));
paymentDetails.ThreeDS.ShouldBeNull();
paymentDetails.Links.ShouldNotBeNull();
paymentDetails.Links.ShouldNotBeEmpty();
paymentDetails.Status.ShouldBe(PaymentStatus.Authorized);
paymentDetails.Source.AsCard().ShouldNotBeNull();
paymentDetails.Approved.ShouldBeTrue();
}
public GetPaymentResponse GetPaymentByPaymentId(GetPaymentRequest req)
{
var res = new GetPaymentResponse();
try
{
long id = long.Parse(req.PaymentId);
using (var container = new TransactionModelContainer())
{
var payment = container.Payments
.Include("PaymentItems")
.FirstOrDefault(x => x.Id == id);
if (payment == null)
{
throw new Exception("Payment is not found");
}
res.SetPaymentResponse(payment);
res.Succeed();
}
}
catch (Exception ex)
{
res.Fail(ex);
CreateLog(ex);
}
return(res);
}
void when_get_payments()
{
context["given a valid request"] = () =>
{
PaymentRequest paymentRequest;
beforeAllAsync = async() =>
{
var source = new Source()
{
{ "type", "ideal" }, { "bic", "INGBNL2A" }, { "description", "Web Payment Demo Unit Test" }
};
currency = Currency.EUR;
amount = 100;
paymentRequest = new PaymentRequest(source, amount, currency);
result = await controller.RequestPayment(paymentRequest); // POST payments
payment = (result as ObjectResult).Value as Resource;
result = await controller.GetPayment((payment as PaymentPending).Id); // GET payments
getPayment = (result as ObjectResult).Value as GetPaymentResponse;
};
it["should return 200 - OK"] = () =>
{
(result as OkObjectResult).StatusCode.ShouldBe(StatusCodes.Status200OK);
};
it["should return the correct payment"] = () =>
{
(getPayment as GetPaymentResponse).Id.ShouldBe((payment as PaymentPending).Id);
};
};
}
public async Task Get_PaymentReturns_ReturnsOkResult()
{
var mockPaymentRepo = new Mock <IPaymentRepository>();
var mockLogger = new Mock <ILogger <PaymentsController> >();
var mockMapper = new Mock <IMapper>();
var mockBankRequestService = new Mock <IBankRequestService>();
var mockEncryptionService = new Mock <IEncryptionService>();
var mapperResponse = new GetPaymentResponse
{
Name = "Fred Bloggs",
CardNumber = "4111111111111111",
Id = Guid.NewGuid(),
PaymentStatus = "Completed"
};
mockPaymentRepo.Setup(x => x.GetPaymentAsync(It.IsAny <Guid>())).ReturnsAsync(() => new Payment());
mockMapper.Setup(x => x.Map <GetPaymentResponse>(It.IsAny <Payment>())).Returns(mapperResponse);
mockEncryptionService.Setup(x => x.Decrypt(It.IsAny <byte[]>())).Returns("4111111111111111");
var paymentsController = new PaymentsController(mockPaymentRepo.Object, mockBankRequestService.Object, mockEncryptionService.Object, mockMapper.Object, mockLogger.Object);
var response = await paymentsController.Get(Guid.NewGuid());
var okResponse = Assert.IsType <OkObjectResult>(response);
var getPaymentResponse = Assert.IsType <GetPaymentResponse>(okResponse.Value);
Assert.Equal(mapperResponse.CardNumber.MaskCard(), getPaymentResponse.CardNumber);
Assert.Equal(mapperResponse.Name, getPaymentResponse.Name);
Assert.Equal(mapperResponse.Id, getPaymentResponse.Id);
Assert.Equal(mapperResponse.PaymentStatus, getPaymentResponse.PaymentStatus);
}
public static void SetPaymentResponse(this GetPaymentResponse res, Payment payment)
{
res.PaymentId = payment.Id;
res.PaymentCode = payment.PaymentCode;
res.CreateBy = payment.CreatedBy;
res.CreateDate = payment.CreatedDate;
res.UpdateBy = payment.UpdatedBy;
res.UpdateDate = payment.UpdatedDate;
res.CustomerIDMPartyID = payment.CustomerIdmPartyId;
res.CustomerCode = null;
res.CustomerName = payment.CustomerName;
res.CustomerAddress = payment.CustomerAddress;
res.CustomerAccountNumber = payment.CustomerRefundAccountNo;
res.CustomerAccountName = payment.CustomerRefundAccountName;
res.CustomerAccountBankId = payment.CustomerRefundBankId;
res.CustomerMobilePhoneNumber = payment.CustomerMobilePhoneNo;
res.Remark = payment.Remark;
res.Ref1 = payment.Ref1;
res.Ref2 = payment.Ref2;
res.Ref3 = payment.Ref3;
res.PaymentStatus = payment.Status;
res.RemainingAmount = payment.RemainingAmount();
res.GrandTotal = payment.GrandTotal();
res.TotalVatAmount = payment.TotalVat();
res.TotalWithholdingTaxAmount = payment.TotalWithholdingTax();
res.TotalBeforeAdjustment = payment.TotalNoDiscount();
res.TotalAdjustment = payment.TotalDiscount();
if (payment.PaymentItems.Count > 0)
{
var items = payment.PaymentItems.ToArray();
res.PaymentItems = new GetPaymentItemResponse[items.Count()];
for (int i = 0; i < items.Length; i++)
{
res.PaymentItems[i] = new GetPaymentItemResponse
{
//ServiceCode = items[i].ServiceCode.ToString(),
//ServiceName = items[i].ServiceName,
ItemDescription = items[i].ItemDescription,
Quantity = items[i].Qty,
UnitAmount = items[i].UnitAmount,
VatPercent = items[i].VatPercent,
WithholdingTaxPercent = items[i].WithholdingTexPercent,
WithholdingTaxAmount = items[i].WithHoldingTaxAmount(),
IsRevenue = items[i].ServiceIsRevenue,
IsLegalPerson = items[i].IsLegalPerson,
VatAmount = items[i].VATAmount(),
Remark = items[i].Remark,
SubTotal = items[i].SubTotal(),
PaymentItemId = items[i].Id,
GroupRef1 = items[i].GroupRef1,
GroupRef2 = items[i].GroupRef2,
GroupRef3 = items[i].GroupRef3,
NetTotal = items[i].NetTotal()
};
}
}
}
public void ShouldDeserializeDefaultGetPaymentResponseInstrumentSender()
{
var fileContent = GetJsonFileContent("./Resources/Sender/GetPaymentResponseInstrumentSender.json");
GetPaymentResponse getPaymentResponse =
(GetPaymentResponse) new JsonSerializer().Deserialize(fileContent, typeof(GetPaymentResponse));
getPaymentResponse.ShouldNotBeNull();
getPaymentResponse.Sender.ShouldNotBeNull();
getPaymentResponse.Sender.Type().ShouldBe(PaymentSenderType.Instrument);
getPaymentResponse.Sender.ShouldBeAssignableTo(typeof(PaymentInstrumentSender));
}
private async Task <IActionResult> GetThreeDsPaymentAsync(string sessionId)
{
GetPaymentResponse payment = await _checkoutApi.Payments.GetAsync(sessionId);
if (payment == null)
{
return(RedirectToAction(nameof(Index)));
}
return(View(payment));
}
public async Task CanGetPaymentDescription()
{
PaymentRequest <CardSource> paymentRequest = TestHelper.CreateCardPaymentRequest();
paymentRequest.Description = "Too descriptive";
PaymentResponse paymentResponse = await _api.Payments.RequestAsync(paymentRequest);
GetPaymentResponse paymentDetails = await _api.Payments.GetAsync(paymentResponse.Payment.Id);
paymentDetails.Description.ShouldBe(paymentRequest.Description);
}
public async Task CanGetPaymentIp()
{
PaymentRequest <CardSource> paymentRequest = TestHelper.CreateCardPaymentRequest();
paymentRequest.PaymentIp = "10.1.2.3";
PaymentResponse paymentResponse = await _api.Payments.RequestAsync(paymentRequest);
GetPaymentResponse paymentDetails = await _api.Payments.GetAsync(paymentResponse.Payment.Id);
paymentDetails.PaymentIp.ShouldBe(paymentRequest.PaymentIp);
}
private async Task GetPaymentDetailsAsync(MerchantOrderViewModel merchantOrder)
{
HttpResponseMessage response = _getToSecureHttpEndpointWithRetries.Get(apiClientUrl: "https://localhost:44379/payments/" + merchantOrder.PaymentId, idServerUrl: "https://localhost:5001", "client", "secret", "CheckoutApi").Result;
if (response.IsSuccessStatusCode)
{
GetPaymentResponse deserialisedResponse = await response.Content.ReadAsAsync <GetPaymentResponse>();
merchantOrder.MaskedCardNumber = deserialisedResponse.MaskedCardNumber;
merchantOrder.ProviderVerifiedPaymentStatus = deserialisedResponse.Succeeded;
}
}
public ActionResult <IPayment> Get(string id)
{
var payment = _paymentRepository.Read(id);
if (payment == null)
{
return(NotFound());
}
GetPaymentResponse resp = new GetPaymentResponse(payment.Id, payment.CardNumber, payment.CardHolderName, payment.Amount, payment.Currency, payment.BankSuccess);
return(Ok(resp));
}
public async Task <IActionResult> GetPayment(string paymentId)
{
try
{
GetPaymentResponse paymentResponse = await api.Payments.GetAsync(paymentId);
return(Ok(paymentResponse));
}
catch (Exception e)
{
return(BadRequest(e.Message));
}
}
public void ShouldDeserializeDefaultGetPaymentResponseCorporateSender()
{
var fileContent = GetJsonFileContent("./Resources/Sender/GetPaymentResponseCorporateSender.json");
GetPaymentResponse getPaymentResponse =
(GetPaymentResponse) new JsonSerializer().Deserialize(fileContent, typeof(GetPaymentResponse));
getPaymentResponse.ShouldNotBeNull();
getPaymentResponse.Sender.ShouldNotBeNull();
getPaymentResponse.Sender.Type().ShouldBe(PaymentSenderType.Corporate);
getPaymentResponse.Sender.ShouldBeAssignableTo(typeof(PaymentCorporateSender));
PaymentCorporateSender sender = (PaymentCorporateSender)getPaymentResponse.Sender;
sender.CompanyName.ShouldNotBeEmpty();
}
public void ShouldDeserializeDefaultGetPaymentResponseAlternativeSender()
{
var fileContent = GetJsonFileContent("./Resources/Sender/GetPaymentResponseAlternativeSender.json");
GetPaymentResponse getPaymentResponse =
(GetPaymentResponse) new JsonSerializer().Deserialize(fileContent, typeof(GetPaymentResponse));
getPaymentResponse.ShouldNotBeNull();
getPaymentResponse.Sender.ShouldNotBeNull();
getPaymentResponse.Sender.Type().ShouldBeNull();
getPaymentResponse.Sender.ShouldBeAssignableTo(typeof(ResponseAlternativeSender));
ResponseAlternativeSender sender = (ResponseAlternativeSender)getPaymentResponse.Sender;
sender["type"].ShouldBe("xyz");
}
private async Task <IActionResult> GetThreeDsPaymentAsync(string sessionId)
{
GetPaymentResponse payment = await _checkoutApi.Payments.GetAsync(sessionId);
//if (payment.Approved)
//{
// return Redirect(_appSettings.ClientURL + "customer/payment-success");
//}
//else
//{
// return Redirect(_appSettings.ClientURL + "customer/payment-failure");
//}
if (!payment.Approved)
{
if (payment.Actions != null)
{
List <Checkout.Payments.PaymentActionSummary> paymentActionSummaries =
payment.Actions.ToList();
if (!string.IsNullOrEmpty(paymentActionSummaries[0].ResponseCode))
{
paymentActionSummaries[0].ResponseSummary = new PaymentStatusCodes().GetPaymentStatus(paymentActionSummaries[0].ResponseCode);
}
}
}
if (payment.Approved)
{
CustomerRegistration customer = _customerService.GetCustomerwithEmail(
((Checkout.Payments.CustomerResponse)payment.Customer).Email);
await _paymentResponseService.InsertPaymentDetails(new PaymentResponseDto {
Amount = Convert.ToDecimal(payment.Amount),
Cardscheme = ((Checkout.Payments.CardSourceResponse)payment.Source).Scheme,
Currency = payment.Currency,
CardType = ((Checkout.Payments.CardSourceResponse)payment.Source).CardType,
PaymentCustomerId = ((Checkout.Payments.CustomerResponse)payment.Customer).Id,
PaymentSourceId = ((Checkout.Payments.CardSourceResponse)payment.Source).Id,
TransactionId = payment.Id,
PaymentDate = payment.RequestedOn,
PaymentStatus = "Approved",
CustomerId = customer.Id,
Card = Convert.ToInt32(((Checkout.Payments.CardSourceResponse)payment.Source).Last4),
TransactionType = ((Checkout.Payments.CardSourceResponse)payment.Source).Type,
OrderId = 0
});
}
return(Ok(payment));
}
public async Task CanGetPaymentMetadata()
{
PaymentRequest <CardSource> paymentRequest = TestHelper.CreateCardPaymentRequest();
var metadata = new KeyValuePair <string, object>("test", "1234");
paymentRequest.Metadata.Add(metadata.Key, metadata.Value);
PaymentResponse paymentResponse = await _api.Payments.RequestAsync(paymentRequest);
GetPaymentResponse paymentDetails = await _api.Payments.GetAsync(paymentResponse.Payment.Id);
paymentDetails.Metadata.ShouldNotBeNull();
paymentDetails.Metadata.ShouldNotBeEmpty();
paymentDetails.Metadata.ShouldHaveSingleItem();
paymentDetails.Metadata.ShouldContain(d => d.Key == metadata.Key && d.Value.Equals(metadata.Value));
}
public async Task CanGetPaymentRecipient()
{
PaymentRequest <CardSource> paymentRequest = TestHelper.CreateCardPaymentRequest();
paymentRequest.Recipient =
new PaymentRecipient(new DateTime(1985, 05, 15), "4242424242", "W1T", "Wensle");
PaymentResponse paymentResponse = await _api.Payments.RequestAsync(paymentRequest);
GetPaymentResponse paymentDetails = await _api.Payments.GetAsync(paymentResponse.Payment.Id);
paymentDetails.Recipient.ShouldNotBeNull();
paymentDetails.Recipient.AccountNumber.ShouldBe(paymentRequest.Recipient.AccountNumber);
paymentDetails.Recipient.DateOfBirth.ShouldBe(paymentRequest.Recipient.DateOfBirth);
paymentDetails.Recipient.LastName.ShouldBe(paymentRequest.Recipient.LastName);
paymentDetails.Recipient.Zip.ShouldBe(paymentRequest.Recipient.Zip);
}
private async Task ShouldGetPaymentDetails()
{
var paymentResponse = new GetPaymentResponse();
_apiClient.Setup(apiClient =>
apiClient.Get <GetPaymentResponse>(PaymentsPath + "/payment_id", _authorization,
CancellationToken.None))
.ReturnsAsync(() => paymentResponse);
IPaymentsClient paymentsClient = new PaymentsClient(_apiClient.Object, _configuration.Object);
var response = await paymentsClient.GetPaymentDetails("payment_id", CancellationToken.None);
response.ShouldNotBeNull();
response.ShouldBeSameAs(paymentResponse);
}
public async Task GivenExistingPayment_WhenGetPaymentIsCalled_ThenPaymentIsReturned()
{
var transactionId = Guid.NewGuid();
var getPaymentByTransactionIdQueryResponse = new GetPaymentByTransactionIdQueryResponse();
var mappedGetPaymentResponse = new GetPaymentResponse();
_mediator.Send(Arg.Is <GetPaymentByTransactionIdQuery>(r => r.TransactionId.Equals(transactionId) && r.ApiKey.Equals(_apiKey)))
.Returns(new Result <GetPaymentByTransactionIdQueryResponse> {
Value = getPaymentByTransactionIdQueryResponse
});
_mapper.Map <GetPaymentResponse>(getPaymentByTransactionIdQueryResponse).Returns(mappedGetPaymentResponse);
var response = await _controller.GetPayment(transactionId);
response.Should().BeOfType <OkObjectResult>();
var getPaymentResponse = ((OkObjectResult)response).Value as GetPaymentResponse;
getPaymentResponse.Should().Be(mappedGetPaymentResponse);
}
public async Task CanGetAlternativePayment()
{
var alternativePaymentSource = new AlternativePaymentSource("giropay")
{
{ "bic", "TESTDETT421" },
{ "purpose", "CKO giropay test" }
};
PaymentPending payment = await RequestAlternativePaymentAsync(alternativePaymentSource);
GetPaymentResponse verifiedPayment = await _api.Payments.GetAsync(payment.Id);
verifiedPayment.ShouldNotBeNull();
verifiedPayment.Id.ShouldBe(payment.Id);
var verifiedSource = verifiedPayment.Source.AsAlternativePayment();
foreach (string key in verifiedSource.Keys)
{
verifiedSource[key].ShouldBe(alternativePaymentSource[key]);
}
}
/// <summary>
/// Maps payment list to payment response - Get
/// </summary>
/// <param name="paymentList"></param>
/// <returns>Ordered list of Payments</returns>
public IEnumerable <GetPaymentResponse> MapPayments(Task <IEnumerable <Payment> > paymentList)
{
List <GetPaymentResponse> listPayment = new List <GetPaymentResponse>();
CultureInfo.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
foreach (var item in paymentList.Result.ToList())
{
GetPaymentResponse payment = new GetPaymentResponse();
payment.Id = item.Id.ToString();
payment.DueDate = item.DueDate;
payment.Status = item.Status;
payment.Category = item.Category;
payment.Description = item.Description;
payment.Amount = Math.Round(item.Amount / 100, 2).ToString("C2", CultureInfo.CurrentCulture);
listPayment.Add(payment);
}
return(listPayment.OrderBy(date => date.DueDate.Year)
.ThenBy(date => date.DueDate.Month)
.ThenBy(date => date.DueDate.Day));
}
public GetPaymentResponse GetPaymentByPaymentId(GetPaymentRequest req)
{
var res = new GetPaymentResponse();
try
{
long id = long.Parse(req.PaymentId);
using (var container = new TransactionModelContainer())
{
var payment = container.Payments
.Include("PaymentItems")
.FirstOrDefault(x => x.Id == id);
if (payment == null) throw new Exception("Payment is not found");
res.SetPaymentResponse(payment);
res.Succeed();
}
}
catch (Exception ex)
{
res.Fail(ex);
CreateLog(ex);
}
return res;
}
