private decimal GetPercentageRate(CreditDto creditDto, string bankAccountType)
{
if (bankAccountType == "Regular")
{
if (creditDto.CreditAmount < 30000m)
{
return(12m);
}
else
{
return(10m);
}
}
else if (bankAccountType == "Corporate")
{
if (creditDto.CreditAmount < 50000m)
{
return(9.5m);
}
else
{
return(7m);
}
}
else
{
return(0m);
}
}
public void CannotCreateCreditWithWrongAmount()
{
//arrange
var creditDto = new CreditDto()
{
UserId = 1, CreditAmount = 60000m, InstallmentCount = 36
};
var mockedBankAccout = new BankAccount()
{
Credits = new Collection <Credit>(),
BankAccountType = new BankAccountType()
{
Name = "Regular"
}
};
_bankAccountRepository.Setup(b => b.GetSingle(It.Is <int>(x => x.Equals(creditDto.UserId)), x => x.BankAccountType, x => x.Credits)).Returns(mockedBankAccout);
var service = InstantiateService();
//act
var result = service.CreateCredit(creditDto);
//assert
Assert.AreEqual("Provided credit amount is not suitable for your account type", result.Message);
Assert.IsFalse(result.Success);
}
public void CanCalculatePercentageRate()
{
//arrange
var sampleData = new CreditDto()
{
UserId = 1, CreditAmount = 10000
};
var mockedBankAccount = new BankAccount()
{
BankAccountType = new BankAccountType()
{
Name = "Regular"
}
};
_bankAccountRepository.Setup(m => m.GetSingle(It.Is <int>(a => a.Equals(sampleData.UserId)), b => b.BankAccountType)).Returns(new BankAccount()
{
BankAccountType = new BankAccountType()
{
Name = "Regular"
}
});
var service = InstantiateService();
//act
var result = service.GetCalculatedPercentageRate(sampleData);
//assert
Assert.AreEqual(12, result.Data);
}
public void CannotCalculatePercentageRateWithCorruptedData()
{
//arrange
var creditDto = new CreditDto()
{
UserId = 1, PercentageRate = -5
};
var mockedBankAccount = new BankAccount()
{
BankAccountType = new BankAccountType()
{
Name = "Corporate"
}
};
_bankAccountRepository.Setup(b => b.GetSingle(It.Is <int>(x => x.Equals(creditDto.UserId)), a => a.BankAccountType)).Returns(mockedBankAccount);
var service = InstantiateService();
//act
var result = service.GetCalculatedPercentageRate(creditDto);
//assert
Assert.AreEqual("Unsupported credit amount", result.Message);
Assert.IsFalse(result.Success);
}
public void CanCreateCredit()
{
//arrange
var creditDto = new CreditDto()
{
UserId = 1, CreditAmount = 12500m, InstallmentCount = 12
};
var mockedBankAccout = new BankAccount()
{
Credits = new Collection <Credit>(),
BankAccountType = new BankAccountType()
{
Name = "Regular"
}
};
_bankAccountRepository.Setup(ba => ba.GetSingle(It.Is <int>(u => u.Equals(creditDto.UserId)), y => y.BankAccountType, t => t.Credits)).Returns(mockedBankAccout);
var service = InstantiateService();
//act
var result = service.CreateCredit(creditDto);
//assert
Assert.IsTrue(result.Success);
Assert.AreEqual("You have submitted a credit request. " +
"Since we are taking care about your safety, the request will be analyzed by our staff. " +
"You will be contacted within 24 hours in order to confirm the credit. ", result.Message);
_creditRepository.Verify(c => c.Create(It.IsAny <Credit>()), Times.Once());
}
public void CannotCreateCreditWhenHasntRepaidExistingOne()
{
//arrange
var creditDto = new CreditDto()
{
UserId = 1, CreditAmount = 12500m, InstallmentCount = 12
};
var mockedBankAccout = new BankAccount()
{
Credits = new Collection <Credit>()
{
new Credit()
{
PaidInFull = false
}
},
BankAccountType = new BankAccountType()
{
Name = "Regular"
}
};
_bankAccountRepository.Setup(b => b.GetSingle(It.Is <int>(x => x.Equals(creditDto.UserId)), x => x.BankAccountType, x => x.Credits)).Returns(mockedBankAccout);
var service = InstantiateService();
//act
var result = service.CreateCredit(creditDto);
//assert
Assert.AreEqual("You already have obtained a credit and it's not fully paid.", result.Message);
Assert.IsFalse(result.Success);
}
private decimal GetInstallmentAmount(CreditDto creditDto)
{
var q = ((creditDto.PercentageRate / 100) / 12) + 1;
var helper = Math.Pow((double)q, creditDto.InstallmentCount);
var installment = creditDto.CreditAmount * (decimal)helper * (q - 1) / ((decimal)helper - 1);
return(installment);
}
private bool ValidateCreditPeriod(CreditDto creditDto)
{
if (creditDto.InstallmentCount < 12 || creditDto.InstallmentCount > 120 || creditDto.InstallmentCount % 12 != 0)
{
return(false);
}
else
{
return(true);
}
}
public void CanCalculateInstallment()
{
//arrange
var sampleData = new CreditDto[]
{
new CreditDto()
{
CreditAmount = 100000, PercentageRate = 10, InstallmentCount = 24
},
new CreditDto()
{
CreditAmount = 20000, PercentageRate = 8.5m, InstallmentCount = 60
},
new CreditDto()
{
CreditAmount = 5000, PercentageRate = 7.2m, InstallmentCount = 12
},
new CreditDto()
{
CreditAmount = 1000000, PercentageRate = 12, InstallmentCount = 120
},
new CreditDto()
{
CreditAmount = 12000, PercentageRate = 50, InstallmentCount = 36
}
};
var expectedValues = new double[]
{
4614.49,
410.33,
433.10,
14347.09,
649.37
};
var service = InstantiateService();
var results = new List <ResultDto <decimal> >();
//act
foreach (var creditDto in sampleData)
{
results.Add(service.GetCalculatedInstallment(creditDto));
}
//assert
for (int i = 0; i < expectedValues.Length; i++)
{
Assert.IsTrue(results[i].Success);
Assert.AreEqual(expectedValues[i], (double)results[i].Data, 0.01);
Assert.AreEqual("We have successfully calculated installment", results[i].Message);
}
}
public static Credit MapToEntity(this CreditDto dto)
{
if (dto == null)
{
return(null);
}
return(new Credit
{
CreditSum = dto.CreditSum,
Comment = dto.Comment
});
}
public IHttpActionResult Calculate([FromUri] CreditDto creditDto)
{
var result = _creditService.GetCalculatedInstallment(creditDto);
if (!result.Success)
{
return(BadRequest(result.Message));
}
else
{
return(Ok(result));
}
}
public IHttpActionResult GetPercentageRate([FromUri] CreditDto creditDto)
{
var userId = User.Identity.GetUserId().Value;
creditDto.UserId = userId;
var result = _creditService.GetCalculatedPercentageRate(creditDto);
if (!result.Success)
{
return(BadRequest(result.Message));
}
else
{
return(Ok(result));
}
}
public ResultDto <decimal> GetCalculatedPercentageRate(CreditDto creditDto)
{
if (creditDto.CreditAmount <= 0 || creditDto.CreditAmount > 10000000m)
{
return(new ResultDto <decimal>()
{
Success = false, Message = "Unsupported credit amount"
});
}
var bankAccount = _bankAccountRepository.GetSingle(creditDto.UserId, ba => ba.BankAccountType);
var bankAccountType = bankAccount.BankAccountType.Name;
var rate = GetPercentageRate(creditDto, bankAccountType);
return(new ResultDto <decimal>()
{
Success = true, Message = "We have successfully calculated percentage rate", Data = rate
});
}
public ResultDto <decimal> GetCalculatedInstallment(CreditDto creditDto)
{
if (creditDto.CreditAmount <= 0)
{
return(new ResultDto <decimal>()
{
Success = false, Message = "The entered amount has to be greater than 0"
});
}
if (creditDto.CreditAmount >= 10000000m)
{
return(new ResultDto <decimal>()
{
Success = false, Message = "The entered amount has to be less than 10 million"
});
}
if (creditDto.PercentageRate <= 0 || creditDto.PercentageRate > 100)
{
return(new ResultDto <decimal>()
{
Success = false, Message = "Percentage rate has to be between 0 and 100%"
});
}
if (creditDto.InstallmentCount <= 0 || creditDto.InstallmentCount > 120 || creditDto.InstallmentCount % 12 != 0)
{
return(new ResultDto <decimal>()
{
Success = false, Message = "We do not support credits for such periods"
});
}
decimal installment = GetInstallmentAmount(creditDto);
return(new ResultDto <decimal>()
{
Success = true, Message = "We have successfully calculated installment", Data = installment
});
}
public async Task <Credit> NewCreditAsync(CreditRequest request, string userId)
{
var creditDto = new CreditDto
{
CreatedAt = DateTime.UtcNow,
BankAccountNumber = request.BankAccountNumber,
BankName = request.BankName,
BudgetId = request.BudgetId,
ContractNumber = request.ContractNumber,
CurrencyId = request.CurrencyId,
Description = request.Description,
InitialCreditValue = request.InitialCreditValue,
InitNoOfPayments = request.InitNoOfPayments,
Name = request.Name,
UserId = userId
};
var credit = _mapper.Map <Credit>(creditDto);
return(await _baseRepository.CreateEntityAsync(credit));
}
public IHttpActionResult ObtainCredit(CreditDto creditDto)
{
if (!ModelState.IsValid)
{
return(BadRequest("Provided data is incorrect"));
}
var userId = User.Identity.GetUserId().Value;
creditDto.UserId = userId;
var result = _creditService.CreateCredit(creditDto);
if (!result.Success)
{
return(BadRequest(result.Message));
}
else
{
return(Ok(result.Message));
}
}
private bool ValidateCreditAmount(CreditDto creditDto, string bankAccountType)
{
if (bankAccountType == "Regular")
{
if (creditDto.CreditAmount >= 2000m && creditDto.CreditAmount <= 50000m)
{
return(true);
}
else
{
return(false);
}
}
else if (bankAccountType == "Corporate")
{
if (creditDto.CreditAmount >= 10000m && creditDto.CreditAmount <= 100000m)
{
return(true);
}
else
{
return(false);
}
}
else if (bankAccountType == "Savings")
{
return(false);
}
else if (bankAccountType == "Student")
{
return(false);
}
else
{
//uncommon situation
return(false);
}
}
public ResultDto CreateCredit(CreditDto creditDto)
{
var bankAccount = _bankAccountRepository.GetSingle(creditDto.UserId, ba => ba.BankAccountType, ba => ba.Credits);
if (bankAccount == null)
{
return new ResultDto()
{
Success = false, Message = "The referenced bank account does not exist"
}
}
;
if (bankAccount.Credits.Any(c => c.PaidInFull == false))
{
return new ResultDto()
{
Success = false, Message = "You already have obtained a credit and it's not fully paid."
}
}
;
if (ValidateCreditPeriod(creditDto) == false)
{
return new ResultDto()
{
Success = false, Message = "Provided credit period is invalid."
}
}
;
if (ValidateCreditAmount(creditDto, bankAccount.BankAccountType.Name) == false)
{
return new ResultDto()
{
Success = false, Message = "Provided credit amount is not suitable for your account type"
}
}
;
decimal percentageRate = GetPercentageRate(creditDto, bankAccount.BankAccountType.Name);
creditDto.PercentageRate = percentageRate;
decimal installmentAmount = GetInstallmentAmount(creditDto);
var credit = new Credit()
{
BankAccount = bankAccount,
BankAccountId = bankAccount.Id,
CreditAmount = creditDto.CreditAmount,
PercentageRate = percentageRate,
DateTaken = DateTime.Now,
Confirmed = false,
ConfirmationDate = null,
InstallmentAmount = installmentAmount,
InstallmentsAlreadyPaid = 0,
PaidInFull = false,
TotalInstallments = creditDto.InstallmentCount,
NextInstallmentDate = null,
};
_creditRepository.Create(credit);
return(new ResultDto()
{
Success = true,
Message = "You have submitted a credit request. " +
"Since we are taking care about your safety, the request will be analyzed by our staff. " +
"You will be contacted within 24 hours in order to confirm the credit. "
});
}
public void CannotCalculateInstallmentWithCorruptedData()
{
//arrange
var sampleData = new CreditDto[]
{
new CreditDto()
{
CreditAmount = 0
},
new CreditDto()
{
CreditAmount = -10
},
new CreditDto()
{
CreditAmount = 10000000
},
new CreditDto()
{
CreditAmount = 10010000
},
new CreditDto()
{
CreditAmount = 10000, PercentageRate = 0
},
new CreditDto()
{
CreditAmount = 10000, PercentageRate = -5
},
new CreditDto()
{
CreditAmount = 10000, PercentageRate = 120
},
new CreditDto()
{
CreditAmount = 10000, PercentageRate = 5, InstallmentCount = 0
},
new CreditDto()
{
CreditAmount = 10000, PercentageRate = 5, InstallmentCount = -4
},
new CreditDto()
{
CreditAmount = 10000, PercentageRate = 5, InstallmentCount = 124
},
new CreditDto()
{
CreditAmount = 10000, PercentageRate = 5, InstallmentCount = 65
},
};
var expected = new string[]
{
"The entered amount has to be greater than 0",
"The entered amount has to be greater than 0",
"The entered amount has to be less than 10 million",
"The entered amount has to be less than 10 million",
"Percentage rate has to be between 0 and 100%",
"Percentage rate has to be between 0 and 100%",
"Percentage rate has to be between 0 and 100%",
"We do not support credits for such periods",
"We do not support credits for such periods",
"We do not support credits for such periods",
"We do not support credits for such periods",
};
var service = InstantiateService();
var results = new List <ResultDto>();
//act
foreach (var creditDto in sampleData)
{
results.Add(service.GetCalculatedInstallment(creditDto));
}
//assert
for (int i = 0; i < sampleData.Length; i++)
{
Assert.IsFalse(results[i].Success);
Assert.AreEqual(expected[i], results[i].Message);
}
Assert.AreEqual(sampleData.Length, expected.Length);
}
