public async Task <CreditResult> Apply(CreditApplyRequest request)
        {
            var score = await _creditScoreService.GetScore(request.IdentificationNumber);

            var creditParameters = new CreditParameters
            {
                Salary = request.Salary,
                Score  = score
            };

            var limit = _limitCalculator.Calculate(creditParameters);

            if (limit <= 0)
            {
                return(CreditResult.Fail());
            }

            var credit = new Credit
            {
                IdentificationNumber = request.IdentificationNumber,
                Name            = request.Name,
                Surname         = request.Surname,
                Salary          = request.Salary,
                TelephoneNumber = request.TelephoneNumber,
                CreditLimit     = limit
            };

            await _creditRepository.InsertAsync(credit);

            return(CreditResult.Success(limit));
        }
Exemple #2
0
 public void RedeemCredits(CreditParameters parameters)
 {
     try
     {
         string path = "/v1/redeem";
         HttpResponseMessage response = _requestManager.RequestAsync(HttpMethod.Post, path, parameters).Result;
         string content = response.Content.ReadAsStringAsync().Result;
         HandleIfErrorResponse(response.StatusCode, content);
     }
     catch (HttpRequestException ex)
     {
         throw new BranchException(ex);
     }
 }
Exemple #3
0
        public void Calculate_WhenScoreIsGreaterThan500AndLowerThan1000AndSalaryIsLowerThan5000_LimitShould10000()
        {
            //Arrange
            var creditParameters = new CreditParameters
            {
                Score  = 600,
                Salary = 300
            };
            //Act
            var limit = _sut.Calculate(creditParameters);

            //Verify
            limit.Should().Be(10000);
        }
Exemple #4
0
        public void Calculate_WhenScoreIsLowerThan500_LimitShouldZero()
        {
            //Arrange
            var creditParameters = new CreditParameters
            {
                Score  = 400,
                Salary = 300
            };
            //Act
            var limit = _sut.Calculate(creditParameters);

            //Verify
            limit.Should().Be(0);
        }
Exemple #5
0
 public ReconcileTransactionResponse ReconcileCredits(CreditParameters parameters)
 {
     try
     {
         string path = "/v1/reconcile";
         HttpResponseMessage response = _requestManager.RequestAsync(HttpMethod.Post, path, parameters).Result;
         string content = response.Content.ReadAsStringAsync().Result;
         HandleIfErrorResponse(response.StatusCode, content);
         return(new ReconcileTransactionResponse(content, response.StatusCode));
     }
     catch (HttpRequestException ex)
     {
         throw new BranchException(ex);
     }
 }
Exemple #6
0
        public async Task RedeemCreditsAsync(CreditParameters parameters)
        {
            try
            {
                string path = "/v1/redeem";
                HttpResponseMessage response = await _requestManager.RequestAsync(HttpMethod.Post, path, parameters).ConfigureAwait(false);

                string content = await response.Content.ReadAsStringAsync().ConfigureAwait(false);

                HandleIfErrorResponse(response.StatusCode, content);
            }
            catch (HttpRequestException ex)
            {
                throw new BranchException(ex);
            }
        }
Exemple #7
0
        public void Calculate_WhenScoreIsGreaterThan1000_LimitShouldSalaryMultiplyCreditLimitMultiplier()
        {
            //Arrange

            const int creditLimitMultiplier = 4;
            var       creditParameters      = new CreditParameters
            {
                Score  = 1100,
                Salary = 3000
            };
            //Act
            var limit = _sut.Calculate(creditParameters);

            //Verify
            limit.Should().Be(3000 * creditLimitMultiplier);
        }
 public decimal Calculate(CreditParameters parameters)
 {
     return(rejectHandler.CalculateLimit(parameters));
 }