public double MITA(double cita, int numberOfMonths)
{
double monthlySalary = cita / numberOfMonths;
double previousCita = monthlySalary * (numberOfMonths - 1);
int min, max;
NükEMEntities db = new NükEMEntities();
List <TaxBracket> taxBracket = db.TaxBrackets.ToList();
int IsOnBorder = 0;
foreach (TaxBracket item in taxBracket)
{
min = item.MinCITA ?? 0;
max = item.MaxCITA ?? 0;
if (cita > min && previousCita < min)
{
IsOnBorder = 1;
}
if (cita > min && cita < max && IsOnBorder == 0)
{
mit = monthlySalary * item.Bracket;
break;
}
else if (cita > min && cita < max && IsOnBorder == 1)
{
TaxBracket previous = db.TaxBrackets.Find(item.Id - 1);
mit = (cita - min) * item.Bracket + (min - previousCita) * previous.Bracket;
break;
}
}
return(Math.Round(mit, 2));
}
public void TaxBracketTest()
{
TaxBracket expected = new TaxBracket(3572, 37000, 0.325m);
Assert.AreEqual(expected.AccumulatedTaxFromPreviousBracket, 3572m);
Assert.AreEqual(expected.MarginalTaxRate, 37000m);
Assert.AreEqual(expected.IncomeThreshold, 0.325m);
}
public void _get_tax_rate(int annualIncome)
{
//Arrange
//Act
TaxBracket taxBracket = _taxService.GetTaxBracket(annualIncome);
//Assert
Assert.AreEqual(taxBracket.BaseRate, 3572);
Assert.AreEqual(taxBracket.TaxPerDollar, 0.325m);
}
public TaxBracketBuilder AddBracket(decimal lowerLimit, decimal upperLimit, decimal taxRate)
{
var taxBracket = new TaxBracket
{
LowerLimit = lowerLimit,
UpperLimit = upperLimit,
TaxRate = taxRate
};
_taxBrackets.Add(taxBracket);
return(this);
}
public EmployeePayslipCalculator()
{
var taxBracket1 = new TaxBracket(0, 18200, 0, 0);
var taxBracket2 = new TaxBracket(18201, 37000, 0, 19);
var taxBracket3 = new TaxBracket(37001, 80000, 3572, 32.5);
var taxBracket4 = new TaxBracket(80001, 180000, 17547, 37);
var taxBracket5 = new TaxBracket(180001, double.MaxValue, 54232, 45);
_taxBrackets = new List <TaxBracket> {
taxBracket1, taxBracket2, taxBracket3, taxBracket4, taxBracket5
};
_targetedPeriod = TargetedPeriod.Monthy;
}
private void TestCalculations(int salary, int rate, TaxBracket taxBracket)
{
var payslipRequest = GetMockRequestData();
payslipRequest.AnnualSalary = salary;
payslipRequest.SuperRate = rate;
var response = _payslipService.GeneratePayslip(payslipRequest);
var expectedGrossIncome = (int)Math.Round((decimal)(salary / 12));
var expectedSuperannuation = (int)Math.Round((decimal)(expectedGrossIncome * rate / 100));
var expectedIncomeTax = salary == 0 ? 0
: (int)Math.Round((taxBracket.Base + (salary - taxBracket.FromIncome) * taxBracket.TaxPerDollar) / 12);
Assert.AreEqual(expectedGrossIncome, response.GrossIncome);
Assert.AreEqual(expectedSuperannuation, response.Superannuation);
Assert.AreEqual(expectedIncomeTax, response.IncomeTax);
Assert.AreEqual(expectedGrossIncome - expectedIncomeTax, response.NetIncome);
}
static void Main(string[] args)
{
var firstNameInput = StandardMessage.CaptureData("first name");
var surnameInput = StandardMessage.CaptureData("surname");
var annualSalaryInput = StandardMessage.CaptureData("annual salary");
var superRateInput = StandardMessage.CaptureData("super rate");
var startDate = StandardMessage.CaptureData("payment start date");
var endDate = StandardMessage.CaptureData("payment end date");
var bracket1 = TaxBracket.Generate(0M, 18200M, 0M, 0M);
var bracket2 = TaxBracket.Generate(18201M, 37000M, 0M, 0.325M);
var bracket3 = TaxBracket.Generate(37001M, 87000M, 3572M, 0.325M);
var bracket4 = TaxBracket.Generate(87001M, 180000M, 19822M, 0.37M);
var bracket5 = TaxBracket.Generate(180000M, Int32.MaxValue, 54232M, 0.45M);
var taxTable = TaxTable.Build(bracket1, bracket2, bracket3, bracket4, bracket5);
EmployeeDetails employeeDetails = EmployeeDetails.ConstructFullName(firstNameInput, surnameInput);
PayPeriod payPeriod = PayPeriod.Generate(startDate, endDate);
GrossIncome grossIncome = GrossIncome.Generate(annualSalaryInput, payPeriod);
IncomeTax incomeTax = IncomeTax.Generate(taxTable, grossIncome, payPeriod);
NetIncome netIncome = NetIncome.Generate(grossIncome, incomeTax);
Super super = Super.Generate(superRateInput, grossIncome);
var paySlip = PaySlip.Create(
employeeDetails,
payPeriod,
grossIncome,
incomeTax,
netIncome,
super
);
var payslipOutput = PayslipBuilder.Print(paySlip);
Console.WriteLine(payslipOutput);
//
}
private int GetIncomeTax(int annualSalary)
{
var previousTaxBracketIncome = 0;
var incomeTax = 0.0;
var found = false;
var taxBrackets = _taxTableRepository.FindAll().ToList();
TaxBracket lastTaxBracket = null;
foreach (var taxBracket in taxBrackets)
{
lastTaxBracket = taxBracket;
if (annualSalary <= taxBracket.MaximumIncome)
{
incomeTax = CalculateIncomeTax(annualSalary, taxBracket, previousTaxBracketIncome);
found = true;
break;
}
if (taxBracket.HasMaximumLimit)
{
previousTaxBracketIncome = taxBracket.MaximumIncome;
}
}
if (found)
{
return((int)Math.Round(incomeTax / 12, MidpointRounding.AwayFromZero));
}
if (lastTaxBracket == null)
{
return(0);
}
if (lastTaxBracket.HasMaximumLimit)
{
// TODO : Move validation to Data Layer
throw new InvalidOperationException("Last Tax Bracket should have max income of -1");
}
incomeTax = CalculateIncomeTax(annualSalary, lastTaxBracket, previousTaxBracketIncome);
return((int)Math.Round(incomeTax / 12, MidpointRounding.AwayFromZero));
}
public void TestBrackets()
{
TaxCalculator calc = new TaxCalculator(100_000.0, 0.0);
Assert.IsTrue(IsClose(calc.TaxesOwed[(int)TaxCalculator.Backets.PER_37], 0.0));
Assert.IsTrue(IsClose(calc.TaxesOwed[(int)TaxCalculator.Backets.PER_35], 0.0));
Assert.IsTrue(IsClose(calc.TaxesOwed[(int)TaxCalculator.Backets.PER_32], 0.0));
{
double min = calc.BracketSet.TaxBrackets[(int)TaxCalculator.Backets.PER_22].UpperBound;
double taxable = 100_000.0 - min;
TaxBracket tw4 = calc.BracketSet.TaxBrackets[(int)TaxCalculator.Backets.PER_24];
double proper = taxable * tw4.Percent;
double actual = calc.TaxesOwed[(int)TaxCalculator.Backets.PER_24];
Assert.IsTrue(IsClose(proper, actual), $"Expected {proper}. Got {actual}");
}
{
double taxable2 = calc.BracketSet.TaxBrackets[(int)TaxCalculator.Backets.PER_22].UpperBound
- calc.BracketSet.TaxBrackets[(int)TaxCalculator.Backets.PER_12].UpperBound;
double target = taxable2 * calc.BracketSet.TaxBrackets[(int)TaxCalculator.Backets.PER_22].Percent;
double actual = calc.TaxesOwed[(int)TaxCalculator.Backets.PER_22];
Assert.IsTrue(IsClose(target, actual), $"Expected {target}. Got {actual}");
}
{
double taxable2 = calc.BracketSet.TaxBrackets[(int)TaxCalculator.Backets.PER_12].UpperBound
- calc.BracketSet.TaxBrackets[(int)TaxCalculator.Backets.PER_10].UpperBound;
double target = taxable2 * calc.BracketSet.TaxBrackets[(int)TaxCalculator.Backets.PER_12].Percent;
double actual = calc.TaxesOwed[(int)TaxCalculator.Backets.PER_12];
Assert.IsTrue(IsClose(target, actual), $"Expected {target}. Got {actual}");
}
{
double taxable2 = calc.BracketSet.TaxBrackets[(int)TaxCalculator.Backets.PER_10].UpperBound;
double target = taxable2 * calc.BracketSet.TaxBrackets[(int)TaxCalculator.Backets.PER_10].Percent;
double actual = calc.TaxesOwed[(int)TaxCalculator.Backets.PER_10];
Assert.IsTrue(IsClose(target, actual), $"Expected {target}. Got {actual}");
}
}
public void CalculatePayroll_ValidInputData_ShouldProduceCorrectPayroll(double taxRate,
double hourlyRate, int timeCardHours, bool seniority, double payroll)
{
// arrange
TaxBracket taxBracket = new TaxBracket
{
TaxRate = taxRate
};
Employee employee = new Employee
{
Seniority = seniority,
HourlyRate = hourlyRate
};
TimeCard timeCard = new TimeCard
{
TotalHours = timeCardHours
};
Mock <ITaxService> taxServiceMock = new Mock <ITaxService>();
Mock <IEmployeeService> employeeServiceMock = new Mock <IEmployeeService>();
Mock <ITimeCardService> timeCardServiceMock = new Mock <ITimeCardService>();
taxServiceMock.Setup(x => x.GetTaxBracket(It.IsAny <double>())).Returns(taxBracket);
employeeServiceMock.Setup(x => x.GetById(It.IsAny <string>())).Returns(employee);
timeCardServiceMock
.Setup(x => x.GetEmployeeTimeCard(It.IsAny <string>(), It.IsAny <DateTime>(), It.IsAny <DateTime>()))
.Returns(timeCard);
var sut = new PayrollCalculator(timeCardServiceMock.Object, employeeServiceMock.Object,
taxServiceMock.Object);
// act
double amount = sut.CalculatePayroll(DateTime.Now, DateTime.Now.AddDays(7), "1");
// assert
Assert.Equal(payroll, amount);
}
public void CalculatePayroll_LessThanOrEqualZeroTimeCardHours_ShouldReturnZero(int hours)
{
// arrange
TaxBracket taxBracket = new TaxBracket
{
TaxRate = 0.2
};
Employee employee = new Employee
{
Seniority = false,
HourlyRate = 25
};
TimeCard timeCard = new TimeCard
{
TotalHours = hours
};
Mock <ITaxService> taxServiceMock = new Mock <ITaxService>();
Mock <IEmployeeService> employeeServiceMock = new Mock <IEmployeeService>();
Mock <ITimeCardService> timeCardServiceMock = new Mock <ITimeCardService>();
taxServiceMock.Setup(x => x.GetTaxBracket(It.IsAny <double>())).Returns(taxBracket);
employeeServiceMock.Setup(x => x.GetById(It.IsAny <string>())).Returns(employee);
timeCardServiceMock
.Setup(x => x.GetEmployeeTimeCard(It.IsAny <string>(), It.IsAny <DateTime>(), It.IsAny <DateTime>()))
.Returns(timeCard);
var sut = new PayrollCalculator(timeCardServiceMock.Object, employeeServiceMock.Object,
taxServiceMock.Object);
// act
double payroll = sut.CalculatePayroll(DateTime.Now, DateTime.Now.AddDays(7), "1");
// assert
Assert.Equal(0, payroll);
}
public double CalculatePayroll(DateTime startDate, DateTime endDate, string employeeId)
{
TimeCard timeCard = _timeCardService.GetEmployeeTimeCard(employeeId, startDate, endDate);
if (timeCard.TotalHours <= 0)
{
return(0);
}
Employee employee = _emplyeeService.GetById(employeeId);
TaxBracket taxBracket = _taxService.GetTaxBracket(employee.HourlyRate);
double bonus = 0;
if (employee.Seniority)
{
bonus = 100;
}
double payPeriodBasePay = employee.HourlyRate * timeCard.TotalHours;
return((payPeriodBasePay + bonus) * (1 - taxBracket.TaxRate));
}
static void Main(string[] args)
{
#region setup context config
IConfigurationBuilder builder = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile("appsettings.json", optional: true);
IConfigurationRoot configuration = builder.Build();
DbContextOptionsBuilder <PayrollDbContext> optionsBuilder = new DbContextOptionsBuilder <PayrollDbContext>();
optionsBuilder.UseSqlServer(configuration.GetConnectionString("DefaultConnection"));
#endregion
PayrollDbContext context = new PayrollDbContext(optionsBuilder.Options);
string payFileOutput = "Employee Id|Total Hours|Health Amount|Life Amount|Tax Rate|Base Pay|Net Pay\r\n";
DateTime startDateTime = Convert.ToDateTime("10/6/2019");
DateTime endDateTime = Convert.ToDateTime("10/20/2019");
// get employee timecards from database
List <TimeCard> timeCards = new List <TimeCard>();
timeCards = context.TimeCards
.Where(x => x.StartDateTime >= startDateTime && x.EndDateDateTime <= endDateTime).ToList();
foreach (var timeCard in timeCards)
{
// fetch details of employee for timecard from database
Employee employee = context.Employees.FirstOrDefault(x => x.Id == timeCard.EmployeeId);
double salary = employee.HourlyRate * 40 * 52;
HttpClient httpClient = new HttpClient();
// get the employee's taxrate from HR system API
string taxRateJson =
httpClient.GetStringAsync(
$"https://test.mocktopus.dev-squared.com/payroll/api/taxrate?salary={salary}&zip={employee.ZipCode}").Result;
TaxBracket taxBracket = JsonConvert.DeserializeObject <TaxBracket>(taxRateJson);
// get the employee's insurance deductions from HR system API
string insuranceJson =
httpClient.GetStringAsync(
$"https://test.mocktopus.dev-squared.com/payroll/api/benefits?id={employee.Id}").Result;
InsuranceAmounts insuranceAmounts = JsonConvert.DeserializeObject <InsuranceAmounts>(insuranceJson);
// calculate net payroll amount
double netPay = 0;
double basePay = timeCard.TotalHours * employee.HourlyRate;
if (employee.Seniority)
{
basePay += 100;
}
if (employee.InsuranceBeforeTaxes)
{
netPay = basePay;
netPay -= insuranceAmounts.Health;
netPay -= insuranceAmounts.Life;
netPay = netPay * (1 - taxBracket.TaxRate);
}
else
{
netPay = basePay * (1 - taxBracket.TaxRate);
netPay -= insuranceAmounts.Health;
netPay -= insuranceAmounts.Life;
}
// output to desired format
payFileOutput +=
$"{employee.Id}|{timeCard.TotalHours}|${insuranceAmounts.Health}|${insuranceAmounts.Life}|{taxBracket.TaxRate}|${basePay}|${netPay}\r\n";
}
Console.WriteLine(payFileOutput);
// send output file wherever needed
Console.ReadLine();
}
private double CalculateIncomeTax(int annualSalary, TaxBracket taxBracket, int previousTaxBracketIncome)
{
var incomeTax = taxBracket.FixedTax + ((annualSalary - previousTaxBracketIncome) * taxBracket.Tax);
return(incomeTax);
}
