public async Task <ObjectResult> Post([FromBody] Payment payment)
{
PaymentValidator paymaentValidator = new PaymentValidator();
ValidationResult valitaionResult = paymaentValidator.Validate(payment);
if (!valitaionResult.IsValid)
{
List <string> errors = new List <string>();
foreach (ValidationFailure failure in valitaionResult.Errors)
{
errors.Add(failure.ErrorMessage);
}
return(BadRequest(String.Join("\n", errors)));
}
var result = await _paymentManager.PostPayment(new PaymentViewPost(payment));
if (payment != null)
{
//if you want to return the created object with status code 201 use Created("/" + result.Id, result);
return(Ok(result));
}
else
{
return(BadRequest("Insufficient funds"));
}
}
public CommunicationResponse UpdatePayment([FromBody] Core.Bills.Models.UpdatePaymentRequest paymentRequest)
{
var response = new CommunicationResponse();
try
{
if (_userService.AuthenticateSession(Request.Headers["Authorization"].ToString()) == false)
{
response.AddError("The authorization credentails were invalid", ErrorCode.SESSION_INVALID);
return(response);
}
PaymentValidator.CheckIfValidPayment(paymentRequest);
_billRepository.UpdatePayment(paymentRequest);
response.Notifications = new List <string>
{
"The payment has been updated"
};
}
catch (ErrorCodeException exception)
{
response.AddError($"An unexpected exception occured: {exception}", paymentRequest, exception.Code);
}
catch (Exception exception)
{
response.AddError($"An unexpected exception occured: {exception}", paymentRequest);
}
return(response);
}
public Result <Payment> CreatePayment(PaymentDTO paymentDTO, Order order)
{
Payment payment = new Payment(paymentDTO.OrderId);
payment.Order = order;
//string failureMessage = payment.IsValid();
PaymentValidator paymentValidator = new PaymentValidator();
var validationResult = paymentValidator.Validate(payment);
//if (failureMessage == string.Empty)
if (validationResult.IsValid)
{
try
{
PaymentsDbSet.Add(payment);
_context.SaveChanges();
return(Result <Payment> .Ok(payment));
}
catch (Exception ex)
{
Console.WriteLine(ex);
return(Result.Fail <Payment>(ex.Message + " " + ex.InnerException));
}
}
else
{
return(Result.Fail <Payment>(string.Join(" ", validationResult.Errors)));
}
//return Result.Fail<Payment>(failureMessage);
}
public async Task Payment_WhenNull_MustReturnCorrespondentErrorMessage()
{
var validator = new PaymentValidator();
var result = await validator.ValidateAsync((Payment)null);
result.Errors.Should().Contain(e => e.ErrorCode.Equals($"Null{typeof(Payment).Name}"));
}
public void Setup()
{
paymentValidator = new PaymentValidator();
string validCreditCardNumber = "1111222233334444";
string shortCreditCardNumber = "111122223333";
string emptyCreditCardNumber = "";
string nullCreditCardNumber = null;
string cardHolder = "Razvan Olariu";
DateTime validDate = new DateTime(2046, 7, 15, 3, 15, 0);
DateTime dateInPast = new DateTime(2016, 7, 15, 3, 15, 0);
decimal cheapPaymentAmmount = 11;
decimal expensivePaymentAmmount = 211;
decimal premiumPaymentAmmount = 1011;
validCreaditCardCheap = new CreditCard(validCreditCardNumber, cardHolder, validDate, cheapPaymentAmmount);
validCreaditCardExpensive = new CreditCard(validCreditCardNumber, cardHolder, validDate, expensivePaymentAmmount);
validCreaditCardPremium = new CreditCard(validCreditCardNumber, cardHolder, validDate, premiumPaymentAmmount);
nonValidCreaditCardCheap = new CreditCard(shortCreditCardNumber, cardHolder, dateInPast, cheapPaymentAmmount);
nonValidCreaditCardExpensive = new CreditCard(emptyCreditCardNumber, cardHolder, dateInPast, expensivePaymentAmmount);
nonValidCreaditCardPremium = new CreditCard(nullCreditCardNumber, cardHolder, dateInPast, premiumPaymentAmmount);
}
public void EditPayment(Payment payment)
{
IValidator validator = PaymentValidator.CreateValidator(payment, true);
validator.Validate();
repository.NewPayment(payment);
}
public async Task Payment_WhenValid_MustReturnValid()
{
var validator = new PaymentValidator();
var payment = this.Fixture.Create <Payment>();
var result = await validator.ValidateAsync(payment);
result.IsValid.Should().BeTrue();
}
public async Task Payment_WhenValueNegative_MustReturnCorrespondentErrorMessage()
{
var validator = new PaymentValidator();
var payment = this.Fixture.Build <Payment>().With(p => p.Value, this.Fixture.Create <decimal>() * -1).Create();
var result = await validator.ValidateAsync(payment);
result.Errors.Should().Contain(e => e.ErrorCode.Equals("PaymentValueNotPositive"));
}
public async Task Payment_WhenISOCurrencyCodeEmpty_MustReturnCorrespondentErrorMessage()
{
var validator = new PaymentValidator();
var payment = this.Fixture.Build <Payment>().With(p => p.ISOCurrencyCode, string.Empty).Create();
var result = await validator.ValidateAsync(payment);
result.Errors.Should().Contain(e => e.ErrorCode.Equals("PaymentISOCurrencyInvalid")).And.NotContain(e => e.ErrorCode.Equals("PaymentISOCurrencyInvalidLength"));
}
public async Task Payment_WhenIdEmpty_MustReturnCorrespondentErrorMessage()
{
var validator = new PaymentValidator();
var payment = this.Fixture.Build <Payment>().With(p => p.Id, Guid.Empty).Create();
var result = await validator.ValidateAsync(payment);
result.Errors.Should().Contain(e => e.ErrorCode.Equals("PaymentIdEmpty"));
}
protected override void OnData()
{
base.OnData();
_paymentValidator = new PaymentValidator();
_paymentValidator.RegisterPaymentValidator();
_settings = SettingsHelper.GetSettings();
IsCreditCardAvailable = _settings.IsCreditCardPageEnabled;
}
public async Task Payment_WhenISOCurrencyCodeTooLong_MustReturnCorrespondentErrorMessage()
{
var validator = new PaymentValidator();
var payment = this.Fixture.Create <Payment>();
payment.ISOCurrencyCode = payment.ISOCurrencyCode.PadRight(10, '0');
var result = await validator.ValidateAsync(payment);
result.Errors.Should().Contain(e => e.ErrorCode.Equals("PaymentISOCurrencyInvalidLength")).And.NotContain(e => e.ErrorCode.Equals("PaymentISOCurrencyInvalid"));
}
public void IsValidAmount(decimal amount, bool status)
{
payment.BSB = "062-223";
payment.AccountNumber = "123456";
payment.AccountName = "xcdh dmncs";
payment.Amount = amount;
PaymentValidator validator = new PaymentValidator();
ValidationResult results = validator.Validate(payment);
Assert.AreEqual(results.IsValid, status);
}
public void IsValidAccountName(string accountName, bool status)
{
payment.BSB = "062-223";
payment.AccountNumber = "123456";
payment.AccountName = accountName;
payment.Amount = 636;
PaymentValidator validator = new PaymentValidator();
ValidationResult results = validator.Validate(payment);
Assert.AreEqual(results.IsValid, status);
}
public void IsValidBSB(string bsb, bool status)
{
payment.BSB = bsb;
payment.AccountNumber = "123456";
payment.AccountName = "Mr shdsmj";
payment.Amount = 636;
PaymentValidator validator = new PaymentValidator();
ValidationResult results = validator.Validate(payment);
Assert.AreEqual(results.IsValid, status);
}
public void PaymentValidator_AggregateException()
{
//Mock
var mock = new Mock <IUserRepository>();
mock.Setup(x => x.GetItemAsync(null)).Returns(Task.FromResult <User>(null));
//Arrange
var manager = new PaymentValidator(mock.Object, _log);
//Act and Assert
Assert.ThrowsException <AggregateException>(() => manager.GetValidatorsResult(new Payment()).Result, "CardDetails property is null. Invalid value.");
}
public IReadOnlyDictionary <string, string> Validate()
{
var validator = new PaymentValidator();
var results = validator.Validate(this);
var domainErrors = new Dictionary <string, string>();
foreach (var result in results.Errors)
{
domainErrors.Add(result.PropertyName, result.ErrorMessage);
}
return(domainErrors);
}
public void AccountId_Is_Greater_Than_Zero_Is_Valid()
{
// Arrange
var validator = new PaymentValidator();
var payment = new Payment {
AccountId = 1
};
// Act
var result = validator.Validate(payment);
// Assert
Assert.False(result.Errors.Any(e => e.ErrorMessage == "AccountId must be a interger greater than 0"));
}
public void Amount_Is_Zero_Generates_Error()
{
// Arrange
var validator = new PaymentValidator();
var payment = new Payment {
Amount = 0.00M
};
// Act
var result = validator.Validate(payment);
// Assert
Assert.True(result.Errors.Any(e => e.ErrorMessage == "Amount must be greater than 0.00"));
}
public void AccountId_Is_Zero_Generates_Error()
{
// Arrange
var validator = new PaymentValidator();
var payment = new Payment {
AccountId = 0
};
// Act
var result = validator.Validate(payment);
// Assert
Assert.True(result.Errors.Any(e => e.ErrorMessage == "AccountId must be a interger greater than 0"));
}
public void Amount_Is_Greater_Than_Zero_Is_Valid()
{
// Arrange
var validator = new PaymentValidator();
var payment = new Payment {
Amount = 0.01M
};
// Act
var result = validator.Validate(payment);
// Assert
Assert.False(result.Errors.Any(e => e.ErrorMessage == "Amount must be greater than 0.00"));
}
public void Cvv_Is_4_Digits_Is_Valid()
{
// Arrange
var validator = new PaymentValidator();
var payment = new Payment {
Cvv = "1234"
};
// Act
var result = validator.Validate(payment);
// Assert
Assert.False(result.Errors.Any(e => e.ErrorMessage == "CVV is invalid"));
}
public void OrderId_Exceeds_50_Characters_Generates_Error()
{
// Arrange
var validator = new PaymentValidator();
var payment = new Payment {
OrderId = "kkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkkk"
};
// Act
var result = validator.Validate(payment);
// Assert
Assert.True(result.Errors.Any(e => e.ErrorMessage == "OrderId cannot exceed 50 characters"));
}
public void Cvv_Has_5_Digits_Generates_Error()
{
// Arrange
var validator = new PaymentValidator();
var payment = new Payment {
Cvv = "12345"
};
// Act
var result = validator.Validate(payment);
// Assert
Assert.True(result.Errors.Any(e => e.ErrorMessage == "CVV is invalid"));
}
public async Task <ResultModel> Update(Payment payment)
{
var result = new ResultModel();
var validatorResult = new PaymentValidator(_paymentRepository, _creditCardRepository).Validate(payment);
if (!validatorResult.IsValid)
{
result.AddNotification(validatorResult.Errors);
return(result);
}
await _paymentRepository.Update(payment);
return(result);
}
public void AndAmountSupplied_ReturnsExpectedResult(decimal amount, bool expectedResult, string errorMessage)
{
//Arrange
var payment = CreateValidPayment();
payment.Amount = amount;
//Act
var result = new PaymentValidator().Validate(payment);
//Assert
result.IsValid.Should().Be(expectedResult);
if (!result.IsValid)
{
AssertErrorMessages(errorMessage, result);
}
}
public ActionResult Index(PaymentViewModel payment)
{
var validator = new PaymentValidator();
var result = validator.Validate(payment);
if (result.IsValid)
{
}
else
{
foreach (ValidationFailure failer in result.Errors)
{
ModelState.AddModelError(failer.PropertyName, failer.ErrorMessage);
}
}
return(View(payment));
}
public void ProcessPayments(string inputFile, string outputFile)
{
try
{
//read and do initial validation
Payments = PaymentIO.ReadPayments(inputFile);
//more validations
Payments = PaymentValidator.ValidateAllPayments(Payments);
//outpu
PaymentIO.WriteCumulativePayments(outputFile, Payments);
}
catch (Exception e)
{
Log("Failed to process payments. " + e.Message);
}
}
public void ValidatePaymentForm(ModelStateDictionary modelState)
{
switch (Type)
{
case PaymentType.Ach:
PaymentValidator.ValidateBankAccountInfo(modelState, Routing, Account);
break;
case PaymentType.CreditCard:
PaymentValidator.ValidateCreditCardInfo(modelState, this);
break;
default:
modelState.AddModelError("Type", "Please select Bank Account or Credit Card.");
break;
}
ValidateBillingDetails(modelState);
}
private void ValidatePaymentForm(PaymentForm pf)
{
switch (pf.Type)
{
case PaymentType.Ach:
PaymentValidator.ValidateBankAccountInfo(ModelState, pf.Routing, pf.Account);
break;
case PaymentType.CreditCard:
PaymentValidator.ValidateCreditCardInfo(ModelState, pf);
break;
default:
ModelState.AddModelError("Type", "Please select Bank Account or Credit Card.");
break;
}
PaymentValidator.ValidateBillingDetails(ModelState, pf);
}
public void PaymentValidator_InvalidCardNumber_Success()
{
//Mock
var mock = new Mock <IUserRepository>();
mock.Setup(x => x.GetItemAsync(It.IsAny <Expression <Func <User, bool> > >())).Returns(Task.FromResult(_user));
//Arrange
var manager = new PaymentValidator(mock.Object, _log);
//Act
var list = manager.GetValidatorsResult(_payment).Result.ToList();
//Assert
Assert.IsTrue(manager.ReturnObject != null);
Assert.IsTrue(list.Any());
foreach (var result in list.Select(item => item.Invoke()).Where(x => x.StatusCode == StatusCode.Failed))
{
Assert.IsTrue(result.StatusCode == StatusCode.Failed);
Assert.AreEqual(result.ErrorCode, ErrorCode.InvalidCardNumber);
}
}
