private double CalculateBasicTaxesDeductionOnBasicTaxes(MuntContext context, ComponentContext componentContext, double basicTaxes)
{
var basicTaxesWithDeduction = basicTaxes;
if (true) //TODO Check from context whether the employee is an inhabitant of Belgium
{
if (true) //TODO Check from context whether the employee is single or has a partner with his/her own income (not on charge)
{
basicTaxesWithDeduction -= 1655.83d;
}
else
{
//Subcalucation based on 30pct of the annualBrutoWage
//max = 10490.00d
//calc
}
}
else //The inhabitant is not a citizen of Belgium
{
//for reference, nothing changes
basicTaxesWithDeduction = basicTaxes;
}
return(basicTaxesWithDeduction);
}
private double CalculateDeductionsForNonCitizens(MuntContext context, ComponentContext componentContext)
{
var deductions = 0.0d;
if (false)//Employee has group insurance
{
}
if (false)//Employee has insurance for old age or premature death
{
}
if (false)//Employee has pension arrangement
{
}
if (false)//Employee has overtime bonus
{
}
if (false)//Employee has workbonus
{
}
return(deductions);
}
private double CalculateDeductions(MuntContext context, ComponentContext componentContext)
{
var deductions = 0.0d;
if (true) //Check if employee is a belgian citizen
{
deductions = CalculateDeductionsForCitizens(context, componentContext);
}
else if (true)//employee is not a citizen,
{
deductions = CalculateDeductionsForNonCitizens(context, componentContext);
}
deductions = Math.Round(deductions, 2);
if (false) //Employee is employed
{
if (deductions <= 2417.96)
{
deductions -= 77.52d;
}
}
else if (false) //Employee is company director
{
if (deductions <= 2157.12d)
{
deductions -= 77.52d;
}
}
return(Math.Round(deductions, 2));
}
public async Task <List <CalculationResult> > Calculate(MuntContext context, ComponentContext componentContext)
{
var calculations = new List <CalculationResult>();
var performanceCodes = context.PerformanceInformation.Performances.Select(p => p.Code).Distinct();
foreach (var performanceCode in performanceCodes)
{
var performances = context.PerformanceInformation.Performances.Where(p => p.Code == performanceCode);
var wage = performances.FirstOrDefault()?.Value;
var description = performances.FirstOrDefault()?.Description;
var hours = performances.Sum(p => p.Hours);
var days = performances.Sum(p => p.Days);
var value = hours * wage;
//Add a calculation result for this area
calculations.Add(CalculationResult.New(componentContext.CalculationAreaOrder, componentContext.Order,
performanceCode.ToString(), description,
days: days,
hours: hours,
value: value.HasValue ? value.Value : 0));
}
return(calculations);
}
private double CalculateBasicTaxesForIndependendOrUnchargedPartner(MuntContext context, ComponentContext componentContext, double annualNettoWage)
{
var taxesByScale = 0.0d;
if (0.01d <= annualNettoWage && annualNettoWage < 11070.00d)
{
taxesByScale = annualNettoWage * 0.2675;
}
else if (11070.00d <= annualNettoWage && annualNettoWage < 12140.00d)
{
taxesByScale = 2961.23 + ((annualNettoWage - 11070.00d) * 0.3210);
}
else if (12140.00d <= annualNettoWage && annualNettoWage < 17590.00d)
{
taxesByScale = 3304.70 + ((annualNettoWage - 12140.00d) * 0.4280);
}
else if (17590.00d <= annualNettoWage && annualNettoWage < 38840.00d)
{
taxesByScale = 5637.30 + ((annualNettoWage - 17590.00d) * 0.4815);
}
else if (38840.00d <= annualNettoWage)
{
taxesByScale = 15869.18 + ((annualNettoWage - 38840.00d) * 0.5350);
}
return(taxesByScale);
}
/// <summary>
/// Bedrijfsvoorheffing
/// </summary>
/// <param name="context"></param>
/// <param name="componentContext"></param>
/// <returns></returns>
public async Task <List <CalculationResult> > Calculate(MuntContext context, ComponentContext componentContext)
{
var calculations = new List <CalculationResult>();
var taxableWage = componentContext.AmountForCalculationArea;
var payrollTax = 0.0d;
//Calculate annual bruto income
var annualBrutoWage =
CalculateLeastCommonDenominator(context, componentContext, taxableWage, 15.00d) * 12; //
//Calculate worker taxes
var workerTaxes = CalculateWorkerTaxes(context, componentContext, annualBrutoWage);
//Netto annual wage = bruto - taxes
var annualNettoWage = annualBrutoWage - workerTaxes;
//Calculate basic taxes
var basicTaxes = CalculateBasicTaxes(context, componentContext, annualNettoWage);
//Calculate deductions on basic taxes
var deductions = CalculateDeductions(context, componentContext);
var annualTaxes = basicTaxes + deductions;
payrollTax = annualTaxes / 12;
calculations.Add(CalculationResult.New(componentContext.CalculationAreaOrder, componentContext.Order,
"BVH", "Bedrijfsvoorheffing", value: -payrollTax));
return(calculations);
}
private double CalculateWorkerTaxesForEmployee(MuntContext context, ComponentContext componentContext, double annualBrutoWage)
{
var workerTaxes = 0.0d;
if (annualBrutoWage < 8620.00d)
{
//30pct
workerTaxes = annualBrutoWage * 0.30;
}
else if (8260.00d <= annualBrutoWage && annualBrutoWage < 20360.00d)
{
//2586.00 + 11pct of anything above 8260.00d
workerTaxes = 2586.00 + (annualBrutoWage - 8260.00d) * 0.11;
}
else if (20360.00d <= annualBrutoWage && annualBrutoWage < 35133.33d)
{
//2586.00 + 3pct of anything above 20360.00d
workerTaxes = 3877.40 + (annualBrutoWage - 20360.00d) * 0.03;
}
else if (35133.33d <= annualBrutoWage)
{
workerTaxes = 4320.00d;
}
return(workerTaxes);
}
private double CalculateDeductionsForCitizens(MuntContext context, ComponentContext componentContext)
{
var deductions = 0.0d;
//charges on family
if (true)
{
deductions += CalculateDeductionForChargesOfFamily(context, componentContext);
}
if (context.EmployeeInformation.NumberOfChildrenOnCharge > 0)//Check if any children on charge
{
deductions += CalculateDeductionChildrenOnCharge(context, componentContext);
}
//personal contributions
//overtime
//low income
//low income govornment sector
//working bonus
return(deductions);
}
private double CalculateDeductionForChargesOfFamilyPartnerNoIncome(MuntContext context, ComponentContext componentContext)
{
var deduction = 0.0d;
//TODO
return(deduction);
}
/// <summary>
/// This calculation will take the bruto wage and round it down to the lowest dividend of 15.
/// </summary>
/// <param name="context"></param>
/// <param name="componentContext"></param>
/// <param name="brutoWage"></param>
/// <param name="dividendBase"></param>
/// <returns></returns>
private double CalculateLeastCommonDenominator(MuntContext context, ComponentContext componentContext, double brutoWage, double dividendBase = 15.00d)
{
//First take the dividend for the current wage without rest
var dividend = Math.Floor(brutoWage / dividendBase);
//Next, calculate the bruto wage according to this scale
var brutoWageAccordingToDivided = dividend * dividendBase;
return(brutoWageAccordingToDivided);
}
private double CalculateDeductionForChargesOfFamilySingleOrPartnerIncome(MuntContext context, ComponentContext componentContext)
{
var deduction = 0.0d;
if (false)//Employee is single or Partner has income
{
deduction = -300.0d;
}
return(deduction);
}
private double CalculateDeductionChildrenOnCharge(MuntContext context, ComponentContext componentContext)
{
var deduction = 0.0d;
var numberOfChildrenOnCharge = context.EmployeeInformation.NumberOfChildrenOnCharge - context.EmployeeInformation.NumberOfChildrenOnChargeWithHandicap;
var numberOfChildrenOnChargeWithHandicap = context.EmployeeInformation.NumberOfChildrenOnChargeWithHandicap;
deduction = CalculateDeductionChildrenOnChargeScale(numberOfChildrenOnCharge);
//Child with handicap *2
deduction += CalculateDeductionChildrenOnChargeScale(numberOfChildrenOnChargeWithHandicap) * 2;
return(deduction);
}
public async Task <List <CalculationResult> > Calculate(MuntContext context, ComponentContext componentContext)
{
var calculations = new List <CalculationResult>();
// If the person has a low income (small wage), there's an additional discount on the Witholding Tax (Bedrijfsvoorheffing)
if (componentContext.AmountForCalculationArea <= 2291.80d)
{
calculations.Add(CalculationResult.New(componentContext.CalculationAreaOrder, componentContext.Order,
"DeductionForSmallWages", "Vermindering BVH van 6.46", value: 6.46d));
}
return(calculations);
}
private double CalculateDeductionForChargesOfFamily(MuntContext context, ComponentContext componentContext)
{
var deduction = 0.0d;
if (true)//is single or partner has income
{
deduction = CalculateDeductionForChargesOfFamilySingleOrPartnerIncome(context, componentContext);
}
else if (false)//partner has no income
{
deduction = CalculateDeductionForChargesOfFamilyPartnerNoIncome(context, componentContext);
}
return(deduction);
}
/// <summary>
/// Based on the type of worker (employee, self employed, company directors, ...)
/// </summary>
/// <param name="context"></param>
/// <param name="componentContext"></param>
/// <param name="annualBrutoWage"></param>
/// <returns></returns>
private double CalculateWorkerTaxes(MuntContext context, ComponentContext componentContext, double annualBrutoWage)
{
var workerTaxes = 0.0d;
if (true) //Check if employee is an employee
{
workerTaxes = CalculateWorkerTaxesForEmployee(context, componentContext, annualBrutoWage);
}
else if (true)//Check if employee is a company director
{
workerTaxes = CalculateWorkerTaxesForCompanyDirector(context, componentContext, annualBrutoWage);
}
return(workerTaxes);
}
/// <summary>
/// Calculates the basic taxes (second scale of calculation, the basic scale)
/// </summary>
/// <param name="context"></param>
/// <param name="componentContext"></param>
/// <param name="annualNettoWage"></param>
/// <returns></returns>
private double CalculateBasicTaxes(MuntContext context, ComponentContext componentContext, double annualNettoWage)
{
var basicTaxes = 0.0d;
if (true) //Check if employee is a belgian citizen
{
basicTaxes = CalculateBasicTaxesForCitizens(context, componentContext, annualNettoWage);
}
else if (true)//employee is not a citizen,
{
basicTaxes = CalculateBasicTaxesByScale(context, componentContext, annualNettoWage);
}
return(Math.Round(basicTaxes, 2));
}
private double CalculateWorkerTaxesForCompanyDirector(MuntContext context, ComponentContext componentContext, double annualBrutoWage)
{
var workerTaxes = 0.0d;
if (annualBrutoWage < 81333.33d)
{
//3pct
workerTaxes = annualBrutoWage * 0.03;
}
else if (81333.33d <= annualBrutoWage)
{
//2586.00 + 11pct of anything above 8260.00d
workerTaxes = 2440.00d;
}
return(workerTaxes);
}
public async Task <List <CalculationResult> > Calculate(MuntContext context, ComponentContext componentContext)
{
var calculations = new List <CalculationResult>();
var bruto = componentContext.AmountForCalculationArea;
var socialWorkBonus = componentContext.CalculationResults.FirstOrDefault(r => r.Code == "SocialWorkBonus");
if (socialWorkBonus != null)
{
var fiscalWorkBonus = socialWorkBonus.Value * 0.1440;
calculations.Add(CalculationResult.New(componentContext.CalculationAreaOrder, componentContext.Order,
"FiscalWorkBonus", "Fiscale werkbonus", value: fiscalWorkBonus));
}
return(calculations);
}
public async Task <List <CalculationResult> > Calculate(MuntContext context, ComponentContext componentContext)
{
var calculations = new List <CalculationResult>();
var dayCompensations =
context.PerformanceInformation.Performances.Where(p => p.Type == PerformanceType.BusinessDayOnSite);
//TODO group by value
if (dayCompensations.Any())
{
var amountOfDays = dayCompensations.Count();
var compensationRate = dayCompensations.FirstOrDefault().Value;
var value = amountOfDays * compensationRate;
calculations.Add(CalculationResult.New(componentContext.CalculationAreaOrder, componentContext.Order,
"DayCompensation", "Bruto Dagvergoeding", value: value));
}
return(calculations);
}
public Task <List <CalculationResult> > Calculate(MuntContext context, ComponentContext componentContext)
{
var calculations = new List <CalculationResult>();
var bruto = componentContext.AmountForCalculationArea;
var bonus = 0.0d;
if (bruto <= 1501.82d)
{
switch (context.EmployeeInformation.EmployeeType)
{
case EmployeeType.WhiteCollar:
bonus = 183.97d;
break;
case EmployeeType.BlueCollar:
bonus = 198.69d;
break;
}
}
else if (1501.82d <= bruto && bruto <= 2385.41d)
{
switch (context.EmployeeInformation.EmployeeType)
{
case EmployeeType.WhiteCollar:
bonus = 183.97d - (0.2082 * (bruto - 1501.82d));
break;
case EmployeeType.BlueCollar:
bonus = 198.69d - (0.2249 * (bruto - 1501.82d));
break;
}
}
else if (2385.41d < bruto)
{
bonus = 0.0d;
}
calculations.Add(CalculationResult.New(componentContext.CalculationAreaOrder, componentContext.Order,
"SocialWorkBonus", "Sociale werkbonus", value: bonus));
return(Task.FromResult(calculations));
}
public async Task <List <CalculationResult> > Calculate(MuntContext context, ComponentContext componentContext)
{
var calculations = new List <CalculationResult>();
//The bruto base salary for the employee
var brutoSalary = context.PerformanceInformation.BaseSalary;
//The number of days that the employee is supposed to work
var performanceBaseline = context.PerformanceInformation.PerformanceBaseline;
//The amount of hours/day that the employee is supposed to work
var contractualHoursPerDay = context.PerformanceInformation.ContractualHoursPerDay;
//The hourly rate for the employee
var hourlyRateForEmployee = (brutoSalary / performanceBaseline) / contractualHoursPerDay;
var performanceCodes = context.PerformanceInformation.Performances
.Where(p =>
p.Type == PerformanceType.BusinessDay ||
p.Type == PerformanceType.Illness ||
p.Type == PerformanceType.WorkingHoliday ||
p.Type == PerformanceType.Holiday)
.Select(p => p.Code)
.Distinct();
foreach (var performanceCode in performanceCodes)
{
var performances = context.PerformanceInformation.Performances.Where(p => p.Code == performanceCode);
var hours = performances.Sum(p => p.Hours);
var description = performances.FirstOrDefault()?.Description;
var days = performances.Sum(p => p.Days);
var value = hourlyRateForEmployee * hours;
//Add a calculation result for this area
calculations.Add(CalculationResult.New(componentContext.CalculationAreaOrder, componentContext.Order,
performanceCode.ToString(), description,
days: days,
hours: hours,
value: value));
}
return(calculations);
}
public Task <List <CalculationResult> > Calculate(MuntContext context, ComponentContext componentContext)
{
var calculations = new List <CalculationResult>();
var bruto = componentContext.AmountForCalculationArea;
var contributionPct = 1d;
if (context.EmployeeInformation.EmployeeType == EmployeeType.BlueCollar)
{
contributionPct = 1.08d;
}
bruto = bruto * contributionPct;
var contribution = -(bruto * 13.07 / 100);
calculations.Add(CalculationResult.New(componentContext.CalculationAreaOrder, componentContext.Order, "RSZ",
"RSZ bijdrage", value: contribution));
return(Task.FromResult(calculations));
}
private double CalculateBasicTaxesForCitizens(MuntContext context, ComponentContext componentContext, double annualNettoWage)
{
var basicTaxes = 0.0d;
if (true)//Check if employee is independend or has no partner on its charge
{
basicTaxes = CalculateBasicTaxesForIndependendOrUnchargedPartner(context, componentContext, annualNettoWage);
//Deduction for belgian citizens
basicTaxes -= 1655.83d;
}
else if (true)//The partner is on the employee's charge
{
//TODO
//Subcalucation based on 30pct of the annualBrutoWage
//max = 10490.00d
//CalculateBasicTaxesByScale
//difference between two result (from employee and partner) is subtracted
//basicTaxes = Addition - 3311.66d
}
return(basicTaxes);
}
// TODO safety check did you mean PluginService?
public async Task <List <CalculationResult> > Calculate(MuntContext context, ComponentContext componentContext)
{
var calculations = new List <CalculationResult>();
var advances = await this.advancesService.GetAdvancesForEmployeeId(context.EmployeeInformation.Id);
var advancesAlreadyPaidInThisPeriod = advances.Where(a =>
context.CalculationInformation.StartDate <= a.PaidOn &&
a.PaidOn <= context.CalculationInformation.EndDate);
if (!advancesAlreadyPaidInThisPeriod.Any())
{
return(calculations); // Nothing to do, short circuit here
}
foreach (var advance in advancesAlreadyPaidInThisPeriod.OrderBy(a => a.PaidOn))
{
calculations.Add(CalculationResult.New(componentContext.CalculationAreaOrder, componentContext.Order,
"Advances", $"Voorschot {advance.PaidOn.DateTime.ToShortDateString()}", value: -(advance.Amount)));
}
return(calculations);
}
