public static void Seed(AppDbContext context)
{
context.Database.EnsureCreated();
if (context.BasicWage.Count() == 0)
{
var basicWage = new BasicWage {
Value = 954M
};
context.BasicWage.Add(basicWage);
context.SaveChanges();
}
if (context.Taxpayer.Count() == 0)
{
var taxpayers = new List <Taxpayer>
{
new Taxpayer
{
Name = "Evandro Gayer Gomes",
CPF = 12345678911,
MonthlyGrossIncome = 6000,
NumberOfDependents = 0,
},
new Taxpayer
{
Name = "Todo User 2",
CPF = 12332112332,
MonthlyGrossIncome = 3500,
NumberOfDependents = 0,
},
new Taxpayer
{
Name = "Todo User 1",
CPF = 11122233311,
MonthlyGrossIncome = 7600,
NumberOfDependents = 2,
},
new Taxpayer
{
Name = "Todo User 3",
CPF = 99988877766,
MonthlyGrossIncome = 7600,
NumberOfDependents = 0,
},
};
foreach (var taxpayer in taxpayers)
{
context.Taxpayer.Add(taxpayer);
}
context.SaveChanges();
}
}
public decimal CalculateDiscountFor(Taxpayer taxpayer, BasicWage basicWage)
{
// Primeiro calcula o desconto de 5% em cima do salário mínimo
var basicWageDiscountPercentage = (basicWage.Value * 5) / 100;
// Então retorna o valor do desconto vezes a quantidade de dependentes
// de um contribuinte.
return(taxpayer.NumberOfDependents * basicWageDiscountPercentage);
}
public void Should_Return_Zero_As_Discount_For_Null_Taxpayer_Or_Basic_Wage()
{
Taxpayer taxpayer = null;
BasicWage basicWage = null;
var discount = _incomeTaxCalulcatorService.CalculateIncomeTaxRateDiscountFor(taxpayer, basicWage);
Assert.AreEqual(0, discount);
}
public async Task Should_Record_Basic_Wage_Data()
{
var basicWage = new BasicWage {
Id = 1, Value = 2000
};
var result = await _basicWageService.RecordBasicWageDataAsync(basicWage);
Assert.IsTrue(result.Success);
Assert.AreEqual(basicWage.Value, result.BasicWage.Value);
}
private void PopulateTaxData(Taxpayer taxpayer, BasicWage basicWage)
{
var discountValue = _incomeTaxCalculatorService.CalculateIncomeTaxRateDiscountFor(taxpayer, basicWage);
taxpayer.IncomeTaxRatePercentage = _incomeTaxCalculatorService.CalculateIncomeTaxRatePercentageFor(taxpayer, basicWage, discountValue);
taxpayer.TotalIncomeTax = _incomeTaxCalculatorService.CalculateTotalIncomeTax(monthlyGrowthRate: taxpayer.MonthlyGrossIncome,
taxRatePercentage: taxpayer.IncomeTaxRatePercentage,
discount: discountValue);
}
/// Calcula o valor de desconto no imposto para um contribuinte do importo de renda, levando em conta o salário mínimo atual.
/// </summary>
/// <param name="taxpayer">Contribuinte.</param>
/// <param name="basicWage">Salário mínimo atual.</param>
/// <returns>Valor de desconto.</returns>
public decimal CalculateIncomeTaxRateDiscountFor(Taxpayer taxpayer, BasicWage basicWage)
{
if (taxpayer == null || basicWage == null)
{
return(0);
}
ITaxpayerDiscountStrategy discountStrategy = TaxpayerDiscountStrategyFactory.GetDiscountStrategyFor(taxpayer);
decimal totalDiscount = discountStrategy.CalculateDiscountFor(taxpayer, basicWage);
return(totalDiscount);
}
public void Should_Return_15_As_Percentage_For_Taxpayer_That_Receives_Up_To_5_Basic_Wages()
{
var taxpayer = new Taxpayer {
MonthlyGrossIncome = 5000
};
var basicWage = new BasicWage {
Value = 1000
};
var percentage = _incomeTaxCalulcatorService.CalculateIncomeTaxRatePercentageFor(taxpayer, basicWage, discount: 0);
Assert.AreEqual(15M, percentage);
}
public void Should_Calculate_Income_Tax_Rate_Discount_For_Taxpayer_With_Dependents()
{
var taxpayer = new Taxpayer {
NumberOfDependents = 1
};
var basicWage = new BasicWage {
Value = 1000
};
var discount = _incomeTaxCalulcatorService.CalculateIncomeTaxRateDiscountFor(taxpayer, basicWage);
Assert.AreEqual(50, discount);
}
/// <summary>
/// Calcula a porcentagem da alíquota do imposto de renda para um contribuinte, levando em conta o salário mínimo atual e eventual
/// desconto nas taxas do imposto.
/// </summary>
/// <param name="taxpayer">Contribuinte.</param>
/// <param name="basicWage">Dados do salário mínimo.</param>
/// <param name="discount">Desconto para o contribuinte.</param>
/// <returns>Porcentagem.</returns>
public decimal CalculateIncomeTaxRatePercentageFor(Taxpayer taxpayer, BasicWage basicWage, decimal discount)
{
// Primeiro calcula a renda líquida para saber a alíquota do imposto.
// Renda líquida = salário bruto mensal - desconto
decimal netIncome = taxpayer.MonthlyGrossIncome - discount;
// Agora calcula a quantidade de salários mínimos que o contribuinte recebe, da seguinte forma:
// Qtd. Salários = renda líqudia / valor do salário mínimo.
var basicWageQuantity = netIncome / basicWage.Value;
// Dependento da quantidade de salários, retorna a porcentagem da alíquota:
return(CalculateIncomeTaxRatePercentageFor(basicWageQuantity));
}
public void Should_Return_0_As_Percentage_For_Taxpayer_That_Receives_Up_To_4_Basic_Wages_But_Has_Enough_Discount()
{
var taxpayer = new Taxpayer {
MonthlyGrossIncome = 2050
};
var basicWage = new BasicWage {
Value = 1000
};
var percentage = _incomeTaxCalulcatorService.CalculateIncomeTaxRatePercentageFor(taxpayer, basicWage, discount: 50);
Assert.AreEqual(0, percentage);
}
public async Task <BasicWageResponse> RecordBasicWageDataAsync(BasicWage basicWage)
{
try
{
var updatedBasicWage = await _basicWageRepository.RecordBasicWageDataAsync(basicWage);
await _unitOfWork.CompleteAsync();
return(BasicWageResponse.CreateSuccess(updatedBasicWage));
}
catch (Exception ex)
{
return(BasicWageResponse.CreateFail(ex.Message));
}
}
public async Task <BasicWage> RecordBasicWageDataAsync(BasicWage basicWage)
{
var basicWageData = await GetBasicWageDataAsync();
if (basicWageData == null)
{
await _context.BasicWage.AddAsync(basicWage);
return(basicWage);
}
basicWageData.Value = basicWage.Value;
_context.BasicWage.Update(basicWageData);
return(basicWageData);
}
public void Should_Return_Five_Percent_Discount_For_Taxpayer_That_Has_Two_Dependents()
{
var basicWage = new BasicWage {
Value = 1000M
};
var taxpayer = new Taxpayer {
NumberOfDependents = 2
};
var expectedDiscountValue = ((basicWage.Value * 5) / 100) * 2; // R$ 100 reais no total
var result = _dependentsTaxpayerDiscountStrategy.CalculateDiscountFor(taxpayer, basicWage);
Assert.AreEqual(expectedDiscountValue, result);
Assert.AreEqual(100, result);
}
public void Should_Not_Return_Discount_For_Taxpayer_That_Does_Not_Have_Dependents()
{
var taxpayer = new Taxpayer
{
MonthlyGrossIncome = 5000,
NumberOfDependents = 0
};
var basicWage = new BasicWage
{
Value = 954M
};
var result = _noTaxpayerDiscountStrategy.CalculateDiscountFor(taxpayer, basicWage);
Assert.AreEqual(0, result);
}
private BasicWageResponse(bool success, string message, BasicWage basicWage) : base(success, message)
{
this.Success = success;
this.Message = message;
this.BasicWage = basicWage;
}
public static BasicWageResponse CreateSuccess(BasicWage basicWage)
{
return(new BasicWageResponse(true, "Sucesso.", basicWage));
}
public decimal CalculateDiscountFor(Taxpayer taxpayer, BasicWage basicWage)
{
return(0);
}
