public void GenerateTax(EmployeePayroll payroll)
{
//Tax computation
//Get old payroll for tax computation
var frequency = _settingService.GetByKey(TAX_FREQUENCY);
FrequencyType taxFrequency = (FrequencyType)Convert.ToInt32(frequency);
var payrollForTaxProcessing =
GetForTaxProcessingByEmployee(payroll.EmployeeId, payroll.PayrollDate,
(taxFrequency == FrequencyType.SemiMonthly ? true : false));
decimal totalTaxableIncome = payroll.TaxableIncome;
foreach (EmployeePayroll employeePayroll in payrollForTaxProcessing)
{
totalTaxableIncome += employeePayroll.TaxableIncome;
//Update Payroll
Update(employeePayroll);
employeePayroll.IsTaxed = true;
}
//Compute tax
var employeeInfo = _employeeInfoService.GetByEmployeeId(payroll.EmployeeId);
var totalTax = _employeePayrollDeductionService
.ComputeTax(payroll.PayrollId, employeeInfo, totalTaxableIncome, taxFrequency);
//Update payroll for total deductions and total grosss
payroll.TotalDeduction += totalTax;
payroll.TotalNet = payroll.TotalGross - payroll.TotalDeduction;
payroll.IsTaxed = true;
}
public Decimal GenerateDeductionsByPayroll(EmployeePayroll employeePayroll)
{
double totalHours = 0;
//Get total number of hours
/* if (isSemiMonthly)
* {
* totalHours = Double.Parse(_settingService.GetByKey(SEMIMONTHLY_TOTAL_HOURS));
* }
* else
* {
* totalHours = Double.Parse(_settingService.GetByKey(MONTHLY_TOTAL_HOURS));
* }*/
//Get employees
//var employeeList = _employeeInfoService.GetAllActive();
var employee = _employeeInfoService.GetByEmployeeId(employeePayroll.EmployeeId);
var deductionList = _deductionService.GetAllCustomizable();
decimal totalDeductions = 0;
//Every deductions check for available deduction for employee
foreach (Deduction deduction in deductionList)
{
var employeeDeduction = _employeeDeductionService
.GetByDeductionAndEmployee(deduction.DeductionId, employee.EmployeeId);
if (employeeDeduction != null)
{
//Create a deduction entry
EmployeePayrollDeduction employeePayrollDeduction =
new EmployeePayrollDeduction
{
EmployeeId = employee.EmployeeId,
DeductionId = deduction.DeductionId,
Amount = employeeDeduction.Amount,
DeductionDate = DateTime.Now,
EmployeePayrollId = employeePayroll.PayrollId
};
_employeePayrollDeductionRepository.Add(employeePayrollDeduction);
totalDeductions += employeeDeduction.Amount;
}
}
return(totalDeductions);
}
/**
* Generate employee leaves
*
**/
public void GenerateEmployeeLeavesPay(DateTime payrollDate, DateTime payrollStartDate, DateTime payrollEndDate)
{
//Get all active leaves within payroll dates
IList <EmployeeLeave> leaves = _employeeLeaveRepository
.GetEmployeePayableLeavesByDateRange(payrollStartDate, payrollEndDate)
.OrderBy(l => l.EmployeeId).ToList();
//for each leaves
foreach (EmployeeLeave leave in leaves)
{
WorkSchedule workSchedule = _employeeWorkScheduleService
.GetByEmployeeId(leave.EmployeeId).WorkSchedule;
var employee = _employeeInfoService.GetByEmployeeId(leave.EmployeeId);
var hourlyRate = _employeeSalaryService.GetEmployeeHourlyRate(employee);
var employeePayrollItem = this.Find(leave.EmployeeId, payrollDate, RateType.Leave);
//for each day in leaves
foreach (DateTime day in DatetimeExtension.EachDay(leave.StartDate, leave.EndDate))
{
//Check if within payroll date
if (day.IsWithinDateRange(payrollStartDate, payrollEndDate))
{
var isRestDay = day.IsRestDay(workSchedule.WeekStart, workSchedule.WeekEnd);
//Will be paid only if employee have schedule on current day
if (!isRestDay)
{
//If more than 8 use 8 hours else use indicated hours
//Note that if the employee will file half day in a date range
//File the half day on a separate entry
var hours = leave.Hours > 8 ? 8 : leave.Hours;
//Update
if (employeePayrollItem != null)
{
_employeePayrollItemRepository.Update(employeePayrollItem);
employeePayrollItem.TotalAmount += (hourlyRate * hours);
employeePayrollItem.TotalHours += hours;
}
else
{
//Create new
EmployeePayrollItem payrollItem = new EmployeePayrollItem
{
EmployeeId = leave.EmployeeId,
PayrollDate = payrollDate,
RateType = RateType.Leave,
Multiplier = 1,
RatePerHour = hourlyRate,
TotalAmount = (hourlyRate * hours),
TotalHours = hours
};
_employeePayrollItemRepository.Add(payrollItem);
}
_unitOfWork.Commit();
}
}
}
}
}
/*Note that this method is applicable to employees with hourly rate*/
public void GenerateEmployeeDailySalaryByDateRange(DateTime dateFrom, DateTime dateTo)
{
//Delete existing by date range
DeleteByDateRange(dateFrom, dateTo);
IList <TotalEmployeeHours> totalEmployeeHours =
_totalEmployeeHoursService.GetByDateRange(dateFrom, dateTo);
Double restDayRate = Double.Parse(_settingService.GetByKey(SettingValue.RATE_REST_DAY));
Double OTRate = Double.Parse(_settingService.GetByKey(SettingValue.RATE_OT));
Double nightDiffRate = Double.Parse(_settingService.GetByKey(SettingValue.RATE_NIGHTDIF));
Double holidayRegularRate = Double.Parse(_settingService.GetByKey(SettingValue.RATE_HOLIDAY_REGULAR));
Double holidaySpecialRate = Double.Parse(_settingService.GetByKey(SettingValue.RATE_HOLIDAY_SPECIAL));
Double OTRateHoliday = Double.Parse(_settingService.GetByKey(SettingValue.RATE_OT_HOLIDAY));
Double holidaySpecialRestDayRate = Double.Parse(_settingService.GetByKey(SettingValue.RATE_HOLIDAY_SPECIAL_REST_DAY));
foreach (TotalEmployeeHours totalHours in totalEmployeeHours)
{
EmployeeInfo employeeInfo = _employeeInfoService.GetByEmployeeId(totalHours.EmployeeId);
var hourlyRate = _employeeSalaryService.GetEmployeeHourlyRate(employeeInfo);
var employeeWorkSchedule =
_employeeWorkScheduleService.GetByEmployeeId(totalHours.EmployeeId);
//No work schedule, no computation
if (employeeWorkSchedule != null)
{
DateTime date = totalHours.Date;
Double rateMultiplier = 0;
var workSchedule = employeeWorkSchedule.WorkSchedule;
var isRestDay = date.IsRestDay(workSchedule.WeekStart, workSchedule.WeekEnd);
Holiday holiday = _holidayService.GetHoliday(date);
//Check if rest day and not special holiday
if (isRestDay &&
!(holiday != null && !holiday.IsRegularHoliday))
{
rateMultiplier *= restDayRate;
}
//Check if holiday
if (holiday != null)
{
if (holiday.IsRegularHoliday)
{
rateMultiplier *= holidayRegularRate;
}
else
{
if (isRestDay)
{
rateMultiplier *= holidaySpecialRestDayRate;
}
else
{
rateMultiplier *= holidaySpecialRate;
}
}
}
//if OT
if (totalHours.Type == RateType.OverTime)
{
//If holiday use holiday ot rate
if (holiday != null)
{
rateMultiplier *= OTRateHoliday;
}
else
{
rateMultiplier *= OTRate;
}
}
decimal totalPayment = 0;
//if NightDif
if (totalHours.Type == RateType.NightDifferential)
{
//rateMultiplier *= nightDiffRate;
/*if (rateMultiplier > 1)
* {
* totalPayment = ((decimal)(totalHours.Hours * (rateMultiplier - 1)) * hourlyRate);
* }*/
totalPayment += (decimal)(nightDiffRate * totalHours.Hours * rateMultiplier);
}
else
{
totalPayment = ((decimal)(totalHours.Hours * rateMultiplier)) * hourlyRate;
}
var employeeDailySalary = new EmployeeDailyPayroll
{
EmployeeId = totalHours.EmployeeId,
Date = totalHours.Date,
TotalPay = totalPayment,
TotalEmployeeHoursId = totalHours.TotalEmployeeHoursId,
RateType = totalHours.Type
};
//Save
_employeeDailyPayrollRepository.Add(employeeDailySalary);
}
}
_unitOfWork.Commit();
//Generate holiday pays
GenerateEmployeeHolidayPay(dateFrom, dateTo);
_unitOfWork.Commit();
}
