public async Task <OperationResult <TaxCalculationResponse> > CalculateTax(TaxCalculationRequest request)
{
OperationResult <TaxCalculationResponse> validatorResult = _validationRuleEngine.Validate(request);
if (validatorResult.HasErrors)
{
return(validatorResult);
}
var calculationTypeMapping = await _calculationMappingRepository.GetByPostalCodeAsync(request.PostalCode).ConfigureAwait(false);
var taxCalculator = _taxCalculatorFactory.GetCalculator(calculationTypeMapping.CalculationType);
var taxYear = await _taxYearRepository.GetTaxYearAsync(_clock.GetCurrentDateTime()).ConfigureAwait(false);
var taxAmountResult = await taxCalculator.CalculateTaxAsync(taxYear, request.AnnualIncome).ConfigureAwait(false);
if (taxAmountResult.HasErrors)
{
return(taxAmountResult.MapErrors <TaxCalculationResponse>());
}
var response = new TaxCalculationResponse
{
TaxYear = taxYear.ToString(),
CalculationType = calculationTypeMapping.CalculationType,
TaxAmount = taxAmountResult.Response
};
await SaveCalculation(request, response, taxYear);
return(new OperationResult <TaxCalculationResponse>(response));
}
private async Task SaveCalculation(TaxCalculationRequest request, TaxCalculationResponse response, TaxYear taxYear)
{
var calculation = new TaxCalculation
{
AnnualIncome = request.AnnualIncome,
TaxAmount = response.TaxAmount,
CalculationType = response.CalculationType,
CreatedBy = request.RequestedBy,
CreationDate = _clock.GetCurrentDateTime(),
PostalCode = request.PostalCode,
TaxYear = taxYear
};
await _calculationRepository.AddAsync(calculation).ConfigureAwait(false);
}
public async Task Calculate_Should_Calculate()
{
//Arrange
const decimal annualIncome = 250000;
const string postalCode = "1234";
const string expectedTaxYear = "Tax Year";
const decimal expectedTaxAmount = 234.56M;
const TaxCalculationType expectedCalculationType = TaxCalculationType.PROGRESSIVE_TAX;
string expectedCalculationTypeDescription = expectedCalculationType.GetDescription();
TaxCalculationRequestModel model = new TaxCalculationRequestModel
{
AnnualIncome = annualIncome,
PostalCode = postalCode
};
TaxCalculationRequest actualManagerRequest = null;
TaxCalculationResponse managerResponse = new TaxCalculationResponse
{
CalculationType = expectedCalculationType,
TaxAmount = expectedTaxAmount,
TaxYear = expectedTaxYear
};
_manager.Setup(r => r.CalculateTax(It.IsAny <TaxCalculationRequest>()))
.Callback((TaxCalculationRequest r) => actualManagerRequest = r)
.ReturnsAsync(() => new OperationResult <TaxCalculationResponse>(managerResponse));
//Act
var result = await _controller.Calculate(model);
//Assert
Assert.IsInstanceOf <OkObjectResult>(result.Result);
TaxCalculationResponseModel
responseMode = (TaxCalculationResponseModel)((OkObjectResult)result.Result).Value;
Assert.AreEqual(expectedCalculationTypeDescription, responseMode.CalculationType);
Assert.AreEqual(expectedTaxYear, responseMode.TaxYear);
Assert.AreEqual(expectedTaxAmount, responseMode.TaxAmount);
_manager.Verify(f => f.CalculateTax(It.IsAny <TaxCalculationRequest>()), Times.Once);
Assert.AreEqual(annualIncome, actualManagerRequest.AnnualIncome);
Assert.AreEqual(postalCode, actualManagerRequest.PostalCode);
}
public async Task <IActionResult> CalculateTaxAsync([FromBody] TaxCalculationRequest taxCalculationRequest)
{
var taxType = await _taxQueryService.GetTaxCalculationTypeByPostalCodeAsync(taxCalculationRequest.PostalCode);
var calculator = _taxRateCalculatorFactory(taxType);
var taxAmountPayable = await calculator.CalculateTaxAmountAsync(taxCalculationRequest.AnnualIncome);
await _taxCommandService.CreateTaxCalculationHistoryAsync(new TaxCalculatorHistoryRequest
{
AnnualIncome = taxCalculationRequest.AnnualIncome,
PostalCode = taxCalculationRequest.PostalCode,
CalculatedTax = taxAmountPayable,
CalculationType = taxType
});
var response = new TaxCalculationResponse
{
TaxCalculationType = taxType,
TaxAmountPayable = taxAmountPayable
};
return(OkApiResponse(response));
}
