public async Task <AuthoriseResponse> Post([FromBody] AuthoriseRequest request)
{
var random = new Random().Next(0, 4);
if (random == 4)
{
throw new Exception("Random Exception");
}
await Task.Delay(random * 1000);
var cardNumber = new CardNumber(request.CardNumber);
if (request.SecurityCode == 200 && cardNumber.IsValid)
{
return(request.Respond(AuthStatus.Authorised));
}
if (request.SecurityCode == 404)
{
return(request.Respond(AuthStatus.Unknown));
}
if (request.SecurityCode == 500)
{
throw new Exception();
}
if (request.SecurityCode == 501)
{
return(request.Respond(AuthStatus.Error));
}
return(request.Respond(AuthStatus.Declined));
}
public async Task Payment_authorisation_failed()
{
var expectedRejectionRequest = new AuthoriseRequest()
{
CardDetails = new CardDetails()
{
CardNumber = "424242424242",
ExpiryDate = "0129",
SecurityCode = "222"
},
MerchantAccount = "CheckoutCom",
Amount = 25.00m,
CurrencyCode = "GBP"
};
var response = await PaymentServiceClient.Authorise(expectedRejectionRequest);
Assert.That(response.HttpStatusCode, Is.EqualTo(HttpStatusCode.UnprocessableEntity));
Assert.NotNull(response.Content.Id);
Assert.That(response.Content.Id, Is.Not.EqualTo("psp_reference_id"));
Assert.That(response.Content.Status, Is.EqualTo("Failed"));
Assert.IsNotEmpty(response.Content.Errors);
ThenValidPaymentAndOrderBody(expectedRejectionRequest, response.Content);
}
public async Task Retrieve_an_existing_payment()
{
var request = new AuthoriseRequest()
{
CardDetails = new CardDetails()
{
CardNumber = "424242424242",
ExpiryDate = "0129",
SecurityCode = "111"
},
MerchantAccount = "CheckoutCom",
Amount = 25.00m,
CurrencyCode = "GBP"
};
var authoriseResponse = await PaymentServiceClient.Authorise(request);
var paymentResponse = await PaymentServiceClient.GetPayment(authoriseResponse.Content.Id, "CheckoutCom");
Assert.That(paymentResponse.HttpStatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.That(paymentResponse.Content.Id, Is.EqualTo(paymentResponse.Content.Id));
Assert.That(paymentResponse.Content.Amount, Is.EqualTo(paymentResponse.Content.Amount));
Assert.That(paymentResponse.Content.CurrencyCode, Is.EqualTo(paymentResponse.Content.CurrencyCode));
Assert.That(paymentResponse.Content.Status, Is.EqualTo(paymentResponse.Content.Status));
Assert.That(paymentResponse.Content.CardDetails.CardNumber, Is.EqualTo(paymentResponse.Content.CardDetails.CardNumber));
Assert.That(paymentResponse.Content.CardDetails.ExpiryDate, Is.EqualTo(paymentResponse.Content.CardDetails.ExpiryDate));
Assert.That(paymentResponse.Content.CardDetails.SecurityCode, Is.EqualTo(paymentResponse.Content.CardDetails.SecurityCode));
}
public void ThenValidPaymentAndOrderBody(AuthoriseRequest request, AuthoriseResponse response)
{
Assert.That(response.Amount, Is.EqualTo(request.Amount));
Assert.That(response.CurrencyCode, Is.EqualTo(request.CurrencyCode));
Assert.That(response.CardDetails.CardNumber, Is.EqualTo(GetFirstSixAndLastFour(response.CardDetails.CardNumber)));
Assert.IsNull(response.CardDetails.SecurityCode);
Assert.That(response.CardDetails.ExpiryDate, Is.EqualTo(request.CardDetails.ExpiryDate));
}
public void SetUp()
{
var fixture = new Fixture();
_authoriseRequest = fixture.Create <AuthoriseRequest>();
_acquirerRequestMapper = new AcquirerRequestMapper();
}
public async Task Payment_authorisation_with_invalid_payment()
{
var invalidRequest = new AuthoriseRequest();
var response = await PaymentServiceClient.Authorise(invalidRequest);
Assert.That(response.HttpStatusCode, Is.EqualTo(HttpStatusCode.BadRequest));
Assert.IsNotEmpty(response.Content.Errors);
}
public ActionResult Confirm()
{
IPayment payment = _payments.GetPayment(_global.GetAllConfigs().FirstOrDefault(x => x.Key == "PaymentClass").Value);
AuthoriseRequest authoriseRequest = new AuthoriseRequest()
{
};
var response = payment.Authorise(authoriseRequest);
return(View());
}
public async Task <ApiResponse <AuthoriseResponse> > Authorise(AuthoriseRequest request)
{
var response = await _httpClient.PostAsJsonAsync("payment/authorise", request);
var content = await response.Content.ReadAsStringAsync();
return(new ApiResponse <AuthoriseResponse>
{
Content = JsonConvert.DeserializeObject <AuthoriseResponse>(content),
HttpStatusCode = response.StatusCode,
Header = response.Headers
});
}
public async Task<IActionResult> Authorise(AuthoriseRequest request)
{
var processor = _paymentProcessorFactory.Get<AuthoriseRequest>();
var result = await processor.ExecuteAsync(request);
var response = _mapper.Map<ProcessorResponse, AuthoriseResponse>(result);
if (response.Status == PaymentStatus.Failed)
{
return UnprocessableEntity(response);
}
return Ok(response);
}
public void SetUp()
{
_fixture = new Fixture();
_acquirerRequest = _fixture.Create <AcquirerRequest>();
_acquirerResponse = _fixture.Create <AcquirerResponse>();
_authoriseRequest = _fixture.Create <AuthoriseRequest>();
_authoriseRequest.CardDetails.CardNumber = "4242 4242 4242 4242";
_repositoryMock = new Mock <IRepository <Payment> >();
_acquirerHandlerMock = new Mock <IAcquirerHandler>();
_cardDetailsMaskerMock = new Mock <ICardDetailsMasker>();
_mapperMock = new Mock <IMapper>();
_authorisationProcessor = new PaymentAuthorisationProcessor(_repositoryMock.Object, _acquirerHandlerMock.Object, _cardDetailsMaskerMock.Object, _mapperMock.Object);
_mapperMock.Setup(x => x.Map <AuthoriseRequest, AcquirerRequest>(It.IsAny <AuthoriseRequest>())).Returns(_acquirerRequest);
_acquirerHandlerMock.Setup(x => x.ProcessAsync(_acquirerRequest)).ReturnsAsync(_acquirerResponse);
}
public async Task <AuthoriseResponse> AuthoriseTransaction(AuthoriseRequest request)
{
var user = RouteData.GetUser();
var cardNumber = new CardNumber(request.CardNumber);
var stopwatch = new Stopwatch();
stopwatch.Start();
var response = await _cardAuthoriser.AuthoriseAsync(request);
stopwatch.Stop();
response.ProcessingTimeMs = Convert.ToInt32(stopwatch.ElapsedMilliseconds);
var transaction = Transaction.Create(response, cardNumber, user);
_dbContext.Transactions.Add(transaction);
await _dbContext.SaveChangesAsync();
return(response);
}
public AuthoriseResponse Authorise(AuthoriseRequest request)
{
AuthoriseResponse response = new AuthoriseResponse();
var options = new PaymentIntentCreateOptions
{
Amount = Convert.ToInt64(request.amount * 100),
Currency = request.currency,
PaymentMethodTypes = new List <string>
{
"card",
},
CaptureMethod = "manual",
//Metadata = request.metadata as Dictionary<string, string>,
};
var service = new PaymentIntentService();
service.Create(options);
return(response);
}
public ActionResult Login([FromBody] AuthoriseRequest loginDetails)
{
string salt;
try
{
salt = _context.Salt.FromSqlInterpolated($"EXECUTE dbo.GetUserSalt {loginDetails.UserId}").ToList().ElementAt(0).Salt;
} catch
{
return(Unauthorized($"User \"{loginDetails.UserId}\" does not exist"));
}
string hashed = GenerateHash(loginDetails.Password, Convert.FromBase64String(salt));
if (AreCredentialsCorrect(loginDetails.UserId, hashed))
{
return(Ok("\"" + GenerateToken(loginDetails.UserId) + "\""));
}
return(Unauthorized("Credentials are wrong"));
}
public ActionResult Register([FromBody] AuthoriseRequest loginDetails)
{
byte[] salt = new byte[128 / 8];
using (var rng = RandomNumberGenerator.Create())
{
rng.GetBytes(salt);
}
string hashed = GenerateHash(loginDetails.Password, salt);
try
{
_ = _context.Database.ExecuteSqlInterpolated($"EXECUTE dbo.CreateUser {loginDetails.UserId}, {hashed}, {Convert.ToBase64String(salt)}"); // this is used for no return values.
} catch
{
return(BadRequest($"Username \"{loginDetails.UserId}\" has already been taken"));
}
return(Ok("\"" + GenerateToken(loginDetails.UserId) + "\""));
}
public async Task <AuthoriseResponse> AuthoriseAsync(AuthoriseRequest request)
{
var json = JsonSerializer.Serialize(request);
var content = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
var pollyContext = new Context();
var httpResponse = await PolicyHandlers.CountRetryPolicy()
.ExecuteAsync(c => _client.PostAsync("api/authorise", content), pollyContext);
if (!httpResponse.IsSuccessStatusCode)
{
var errorResponse = AuthoriseResponse.CreateFailedResponse(
request, pollyContext.GetRetryCount());
return(errorResponse);
}
var result = await httpResponse.Content.DeserializeAsync <AuthoriseResponse>();
result.RetryAttempts = pollyContext.GetRetryCount();
return(result);
}
public async Task Authorise_a_payment_successfully()
{
var expectedSuccessRequest = new AuthoriseRequest()
{
CardDetails = new CardDetails()
{
CardNumber = "424242424242",
ExpiryDate = "0129",
SecurityCode = "111"
},
MerchantAccount = "CheckoutCom",
Amount = 25.00m,
CurrencyCode = "GBP"
};
var response = await PaymentServiceClient.Authorise(expectedSuccessRequest);
Assert.That(response.HttpStatusCode, Is.EqualTo(HttpStatusCode.OK));
Assert.NotNull(response.Content.Id);
Assert.That(response.Content.Id, Is.Not.EqualTo("psp_reference_id"));
Assert.That(response.Content.Status, Is.EqualTo("Accepted"));
ThenValidPaymentAndOrderBody(expectedSuccessRequest, response.Content);
}
public Task <AuthoriseResult> Authorise(AuthoriseRequest request) => Task.FromException <AuthoriseResult>(new Exception("ERROR AUTHORISING PAYMENT"));
public Task <AuthoriseResult> Authorise(AuthoriseRequest request)
{
LastRequest = request;
return(Task.FromResult(authResult));
}
public AuthoriseResponse Authorise(AuthoriseRequest request)
{
throw new NotImplementedException();
}
public Task <AuthoriseResult> Authorise(AuthoriseRequest request) => Task.FromResult(AuthoriseResult.Approved);
public Task <AuthoriseResult> Authorise(AuthoriseRequest request) => Task.FromResult(AuthoriseResult.Denied);
