public void Arrange()
{
_sut = new PaymentStatusModel()
{
PaymentIsStopped = false,
LearnerMatchFound = true,
HasDataLock = false,
InLearning = true,
PausePayments = false,
RequiresNewEmployerAgreement = false,
WithdrawnByCompliance = false,
WithdrawnByEmployer = false,
EmploymentCheckPassed = true
};
}
public async Task TestE2E_CreatePayment_John_ValidAmazon_Async()
{
var johnDoeCard = Helper.GenerateCard_JohnDoe();
// Arrange
var request = new
{
Url = "/api/merchantcardpayments",
Body = new
{
MerchantId = amazonValidMerchantGuid.ToString(),
RequestId = Guid.NewGuid().ToString(),
CardNumber = johnDoeCard.CardNumber,
CardHolderName = johnDoeCard.CardHolderName,
MonthExpiryDate = johnDoeCard.MonthExpiryDate,
YearExpiryDate = johnDoeCard.YearExpiryDate,
CVV = johnDoeCard.CVV,
Currency = "GBP",
Amount = 10
}
};
// Act
var merchantPaymentHttpResponse = await PgApiClient.PostAsync(request.Url, ContentHelper.GetStringContent(request.Body));
merchantPaymentHttpResponse.EnsureSuccessStatusCode();
var merchantPaymentResponseString = await merchantPaymentHttpResponse.Content.ReadAsStringAsync();
var merchantPaymentResponse = JsonConvert.DeserializeObject <CreatePaymentResponseModel>(merchantPaymentResponseString);
PaymentStatusModel paymentStatus = new PaymentStatusModel()
{
Status = ""
};
// loop to get the value of the payment status from the PaymentGateway.Processor
for (int i = 0; i < 3; i++)
{
await Task.Delay(500);
try
{
// Arrange
var paymetProcessorRequest = $"/api/PaymentStatuses?paymentId={merchantPaymentResponse.PaymentRequestId}";
// Act
var response = await PgProcApiClient.GetAsync(paymetProcessorRequest);
if (response.IsSuccessStatusCode)
{
var stringResponse = await response.Content.ReadAsStringAsync();
paymentStatus = JsonConvert.DeserializeObject <PaymentStatusModel>(stringResponse);
if (paymentStatus.Status == PaymentStatusEnum.Scheduled.ToString())
{
await Task.Delay(1000);
}
else
{
break;
}
}
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
Assert.Equal(PaymentStatusEnum.Completed.ToString(), paymentStatus.Status);
// this to check the consistency of the distributed operation
Assert.Equal(merchantPaymentResponse.RequestId, paymentStatus.RequestId);
}
public static PaymentStatusModel ToStatusApiModel(this PaymentRequestDetailsMessage src)
{
PaymentStatusModel response = new PaymentStatusModel
{
Id = src.Id,
PaymentAsset = src.PaymentAssetId,
SettlementAsset = src.SettlementAssetId,
OrderId = src.OrderId,
PaymentRequest = new PaymentRequestModel
{
Amount = src.Order?.PaymentAmount,
Address = src.WalletAddress,
CreatedAt = src.Timestamp.ToIsoDateTime(),
ExchangeRate = src.Order?.ExchangeRate,
ExpirationDt = src.DueDate.ToIsoDateTime(),
Transactions = src.Transactions.Any() ? src.Transactions.Select(Mapper.Map <PaymentTransactionModel>).ToList() : null
}
};
switch (src.Status)
{
case PaymentRequestStatus.New:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentRequestCreated;
break;
case PaymentRequestStatus.Confirmed:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentConfirmed;
break;
case PaymentRequestStatus.InProcess:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentInProgress;
break;
case PaymentRequestStatus.Cancelled:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentCancelled;
break;
case PaymentRequestStatus.Error:
switch (src.ProcessingError)
{
case PaymentRequestProcessingError.PaymentAmountAbove:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentError;
response.Error = new ErrorModel {
Code = PaymentRequestErrorPublicCodes.PaymentAmountAbove
};
break;
case PaymentRequestProcessingError.PaymentAmountBelow:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentError;
response.Error = new ErrorModel {
Code = PaymentRequestErrorPublicCodes.PaymentAmountBelow
};
break;
case PaymentRequestProcessingError.PaymentExpired:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentError;
response.Error = new ErrorModel {
Code = PaymentRequestErrorPublicCodes.PaymentExpired
};
break;
case PaymentRequestProcessingError.LatePaid:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentError;
response.Error = new ErrorModel {
Code = PaymentRequestErrorPublicCodes.LatePaid
};
break;
case PaymentRequestProcessingError.RefundNotConfirmed:
response.PaymentStatus = PaymentRequestPublicStatuses.RefundError;
response.RefundRequest = Mapper.Map <RefundRequestModel>(src.Refund);
response.Error = new ErrorModel
{
Code = PaymentRequestErrorPublicCodes.TransactionNotConfirmed
};
break;
case PaymentRequestProcessingError.UnknownPayment:
response.PaymentStatus = PaymentRequestPublicStatuses.PaymentError;
break;
case PaymentRequestProcessingError.UnknownRefund:
response.PaymentStatus = PaymentRequestPublicStatuses.RefundError;
response.RefundRequest = Mapper.Map <RefundRequestModel>(src.Refund);
response.Error = new ErrorModel
{
Code = PaymentRequestErrorPublicCodes.RefundIsNotAvailable
};
break;
default:
throw new Exception("Unknown payment request error type");
}
break;
case PaymentRequestStatus.RefundInProgress:
response.PaymentStatus = PaymentRequestPublicStatuses.RefundInProgress;
response.RefundRequest = Mapper.Map <RefundRequestModel>(src.Refund);
break;
case PaymentRequestStatus.Refunded:
response.PaymentStatus = PaymentRequestPublicStatuses.RefundConfirmed;
response.RefundRequest = Mapper.Map <RefundRequestModel>(src.Refund);
break;
default:
throw new Exception("Unknown payment request status");
}
return(response);
}
public Payment PaymentStatus(long paymentId, [FromBody] PaymentStatusModel model)
{
return(this._paymentService.PaymentStatus(_connectorFactory.Create(model), paymentId));
}