public List <VMOvertimeApprovalChild> GetIndex(VMLoggedUser user, int PayrollPeriodID)
{
List <VHR_EmployeeProfile> dbEmployees = GetSpecificEmployeeService.GetSpecificEmployees(user);
List <MonthData> monthDatas = new List <MonthData>();
if (user.UserRoleID == "U") // HR Normal
{
Expression <Func <MonthData, bool> > SpecificEntries = c => c.PayrollPeriodID == PayrollPeriodID && c.MonthDataStageID == "P" && (c.EncashbaleSingleOT > 0 || c.EncashbaleDoubleOT > 0 || c.CPLConversionOT > 0);
monthDatas = MonthDataReporsitory.FindBy(SpecificEntries);
}
else if (user.UserRoleID == "H") // HR Admin
{
Expression <Func <MonthData, bool> > SpecificEntries = c => c.PayrollPeriodID == PayrollPeriodID && c.MonthDataStageID == "A" && (c.EncashbaleSingleOT > 0 || c.EncashbaleDoubleOT > 0 || c.CPLConversionOT > 0);
monthDatas = MonthDataReporsitory.FindBy(SpecificEntries);
}
else if (user.UserRoleID == "A") // Admin
{
Expression <Func <MonthData, bool> > SpecificEntries = c => c.PayrollPeriodID == PayrollPeriodID && c.MonthDataStageID == "P" && (c.EncashbaleSingleOT > 0 || c.EncashbaleDoubleOT > 0 || c.CPLConversionOT > 0);
monthDatas = MonthDataReporsitory.FindBy(SpecificEntries);
}
List <VMOvertimeApprovalChild> VMOvertimeApprovalChildList = new List <VMOvertimeApprovalChild>();
PayrollPeriod payrollPeriod = DDService.GetAllPayrollPeriod().Where(aa => aa.PPayrollPeriodID == PayrollPeriodID).First();
foreach (var dbEmployee in dbEmployees)
{
VMOvertimeApprovalChild vmOvertimeApprovalChild = new VMOvertimeApprovalChild();
if (monthDatas.Where(aa => aa.EmployeeID == dbEmployee.PEmployeeID).Count() > 0)
{
vmOvertimeApprovalChild = GetConveretedOTList(vmOvertimeApprovalChild, dbEmployee, monthDatas.First(aa => aa.EmployeeID == dbEmployee.PEmployeeID), payrollPeriod);
VMOvertimeApprovalChildList.Add(vmOvertimeApprovalChild);
}
}
return(VMOvertimeApprovalChildList);
}
private decimal TaxWithholdCalculateMonth(PayrollPeriod period, decimal taxableIncome, decimal taxableBase)
{
uint year = period.Year();
decimal taxWithhold = 0m;
if (taxableBase <= 0m)
{
taxWithhold = 0m;
}
else
{
if (period.Year() < 2008)
{
taxWithhold = 0m;
}
else if (period.Year() < 2013)
{
taxWithhold = FixTaxRoundUp(BigMulti(taxableBase, TaxAdvBracket1(year)));
}
else
{
taxWithhold = FixTaxRoundUp(BigMulti(taxableBase, TaxAdvBracket1(year)));
}
}
return(taxWithhold);
}
public decimal MinMaxAssesmentBase(PayrollPeriod period, decimal insBase)
{
decimal minBase = MinAssesmentBase(period, insBase);
decimal maxBase = MaxAssesmentBase(period, minBase);
return(maxBase);
}
public override PayrollResult Evaluate(PayrollPeriod period, PayTagGateway tagConfig, IDictionary <TagRefer, PayrollResult> results)
{
bool pensionSaving = false;
PaymentResult resultPension = (PaymentResult)GetResultBy(results, TAG_PENSION_CONT);
decimal paymentIncome = 0m;
if (!Interest())
{
paymentIncome = 0m;
}
else
{
IncomeBaseResult resultIncome = (IncomeBaseResult)GetResultBy(results, TAG_AMOUNT_BASE);
pensionSaving = resultPension.Interest();
paymentIncome = Math.Max(0m, resultIncome.EmployeeBase());
}
decimal contPaymentValue = InsuranceContribution(period, paymentIncome, pensionSaving);
var resultValues = new Dictionary <string, object>()
{
{ "payment", contPaymentValue }
};
return(new PaymentDeductionResult(TagCode, Code, this, resultValues));
}
public VMOvertimeApproval GetCreate3(VMOvertimeApprovalSelection es, int?[] SelectedEmployeeIds, VMOvertimeApproval vmOvertimeApproval)
{
List <MonthData> monthDatas = new List <MonthData>();
List <OTPolicy> dbOTPolicies = DDService.GetOTPolicy();
List <VMOvertimeApprovalChild> vmOvertimeApprovalChildList = new List <VMOvertimeApprovalChild>();
List <VHR_EmployeeProfile> employees = DDService.GetEmployeeInfo();
PayrollPeriod payrollPeriod = DDService.GetPayrollPeriod().First(aa => aa.PPayrollPeriodID == es.PayrollPeriodID); // Get selected Payroll Period
Expression <Func <MonthData, bool> > SpecificEntries = c => c.PayrollPeriodID == payrollPeriod.PPayrollPeriodID && (c.EncashbaleSingleOT > 0 || c.EncashbaleDoubleOT > 0 || c.CPLConversionOT > 0);
monthDatas = MonthDataReporsitory.FindBy(SpecificEntries);
foreach (int empid in SelectedEmployeeIds)
{
if (monthDatas.Where(aa => aa.EmployeeID == empid).Count() > 0)
{
MonthData monthData = new MonthData();
monthData = monthDatas.First(aa => aa.EmployeeID == empid);
VMOvertimeApprovalChild vmOvertimeApprovalChild = new VMOvertimeApprovalChild();
VHR_EmployeeProfile employee = employees.First(aa => aa.PEmployeeID == empid);// Get Specific Employee
vmOvertimeApprovalChild = GetConveretedOTList(vmOvertimeApprovalChild, employee, monthData, payrollPeriod);
vmOvertimeApprovalChildList.Add(vmOvertimeApprovalChild);
}
}
vmOvertimeApproval.PayrollPeriodID = payrollPeriod.PPayrollPeriodID;
vmOvertimeApproval.PayrollPeriodName = payrollPeriod.PRName;
vmOvertimeApproval.OvertimeApprovalChild = vmOvertimeApprovalChildList;
return(vmOvertimeApproval);
}
private void btnGenerated_Click(object sender, EventArgs e)
{
Cursor.Current = Cursors.WaitCursor;
var period = new PayrollPeriod();
using (var f = new frmGenerated_Open())
{
f.ShowDialog();
period = f.ItemData;
}
if (period == null)
{
return;
}
var frm = new frmPayroll
{
ItemData = period,
Header = $" PAYROLL - {period.DateCovered:MMMM dd, yyyy} [{period.Remarks}]"
};
OpenForm(frm, "Payroll " + period.DateCovered.ToString("dd MMM yyyy"));
}
public override PayrollResult Evaluate(PayrollPeriod period, PayTagGateway tagConfig, IDictionary <TagRefer, PayrollResult> results)
{
decimal employerIncome = 0m;
decimal employeeIncome = 0m;
if (!Interest())
{
employerIncome = 0m;
employeeIncome = 0m;
}
else
{
IncomeBaseResult resultIncome = (IncomeBaseResult)GetResultBy(results, TAG_AMOUNT_BASE);
employerIncome = Math.Max(0m, resultIncome.EmployerBase());
employeeIncome = Math.Max(0m, resultIncome.EmployeeBase());
}
decimal contPaymentValue = InsuranceContribution(period, employerIncome, employeeIncome);
var resultValues = new Dictionary <string, object>()
{
{ "payment", contPaymentValue }
};
return(new PaymentDeductionResult(TagCode, Code, this, resultValues));
}
public VMOvertimeEncashable GetCreate3(VMOvertimeEncashableSelection es, int?[] SelectedEmployeeIds, VMOvertimeEncashable vmOvertimeApproval)
{
List <VMOvertimeEncashableChild> vmOvertimeApprovalChildList = new List <VMOvertimeEncashableChild>();
List <VHR_EmployeeProfile> employees = DDService.GetEmployeeInfo(); // Get All Employees from database
PayrollPeriod payrollPeriod = DDService.GetPayrollPeriod().First(aa => aa.PPayrollPeriodID == es.PayrollPeriodID); // Get selected Payroll Period
foreach (int empid in SelectedEmployeeIds)
{
VMOvertimeEncashableChild vmOvertimeApprovalChild = new VMOvertimeEncashableChild();
VHR_EmployeeProfile employee = employees.First(aa => aa.PEmployeeID == empid);// Get Specific Employee
vmOvertimeApprovalChild.EmpID = employee.PEmployeeID;
vmOvertimeApprovalChild.EmpNo = employee.OEmpID;
vmOvertimeApprovalChild.EmployeeName = employee.EmployeeName;
vmOvertimeApprovalChild.OvertimePolicyID = employee.OTPolicyID;
vmOvertimeApprovalChild.OvertimePolicyName = employee.OTPolicyName;
vmOvertimeApprovalChild.ApprovedOT = 80;
vmOvertimeApprovalChild.EncashableOT = 56;
vmOvertimeApprovalChild.CPLConvertedOT = 24;
vmOvertimeApprovalChild.PayrollPeriodID = payrollPeriod.PPayrollPeriodID;
vmOvertimeApprovalChild.PayrollPeriodName = payrollPeriod.PRName;
vmOvertimeApprovalChildList.Add(vmOvertimeApprovalChild);
}
vmOvertimeApproval.PayrollPeriodID = payrollPeriod.PPayrollPeriodID;
vmOvertimeApproval.PayrollPeriodName = payrollPeriod.PRName;
vmOvertimeApproval.OvertimeEncashableChild = vmOvertimeApprovalChildList;
return(vmOvertimeApproval);
}
private int[] ComputeResultValue(PayrollPeriod period, int hoursWeekly)
{
int hoursDaily = hoursWeekly / 5;
int[] hoursWeek = new int[] { hoursDaily, hoursDaily, hoursDaily, hoursDaily, hoursDaily, 0, 0 };
return(hoursWeek);
}
public ActionResult Create(PayrollPeriodViewModels collection)
{
try
{
if (ModelState.IsValid)
{
PayrollPeriod toDB = new PayrollPeriod();
toDB.PayrollPeriodDescription = collection.PayrollPeriodDescription;
toDB.PayPeriodFrom = collection.PayPeriodFrom;
toDB.PayPeriodTo = collection.PayPeriodTo;
toDB.WorkDays = collection.WorkDays;
toDB.WorkHours = collection.WorkHours;
toDB.Year = collection.PayPeriodFrom.Year;
toDB.Month = Helper.GetMonthName(collection.PayPeriodFrom.Month);
payrollPeriodBL.InsertPayrollPeriod(toDB);
return(RedirectToAction("Index"));
}
else
{
ModelState.AddModelError("", "Error.");
return(View(collection));
}
}
catch
{
ModelState.AddModelError("", "Error.");
return(View(collection));
}
}
public ActionResult Edit(int?id)
{
PayrollPeriod obj = PayrollPeriodService.GetEdit((int)id);
HelperMethod(obj);
return(PartialView(obj));
}
public override PayrollResult Evaluate(PayrollPeriod period, PayTagGateway tagConfig, IDictionary <TagRefer, PayrollResult> results)
{
PaymentResult advanceBaseResult = (PaymentResult)GetResultBy(results, TAX_ADVANCE);
TaxClaimResult reliefClaimPayerResult = (TaxClaimResult)GetResultBy(results, TAX_CLAIM_PAYER);
TaxClaimResult reliefClaimDisabResult = (TaxClaimResult)GetResultBy(results, TAX_CLAIM_DISAB);
TaxClaimResult reliefClaimStudyResult = (TaxClaimResult)GetResultBy(results, TAX_CLAIM_STUDY);
decimal advanceBaseValue = advanceBaseResult.Payment();
decimal reliefPayerValue = reliefClaimPayerResult.TaxRelief();
decimal reliefDisabValue = reliefClaimDisabResult.TaxRelief();
decimal reliefStudyValue = reliefClaimStudyResult.TaxRelief();
decimal taxReliefValue = 0m;
decimal taxClaimsValue = reliefPayerValue + reliefDisabValue + reliefStudyValue;
decimal resultValue = ComputeResultValue(advanceBaseValue,
taxReliefValue, taxClaimsValue);
var resultValues = new Dictionary <string, object>()
{
{ "tax_relief", resultValue }
};
return(new TaxReliefResult(TagCode, Code, this, resultValues));
}
public decimal SocialInsuranceFactor(PayrollPeriod period, bool pensPill)
{
decimal factor = 0m;
if (period.Year() < 1993)
{
factor = 0m;
}
else if (period.Year() < 2009)
{
factor = 8.0m;
}
else if (period.Year() < 2013)
{
factor = 6.5m;
}
else
{
if (pensPill)
{
factor = 3.5m;
}
else
{
factor = 6.5m;
}
}
return(decimal.Divide(factor, 100));
}
private decimal TaxAdvCalculateMonth(PayrollPeriod period, decimal taxableIncome, decimal taxableBase)
{
uint year = period.Year();
decimal taxAdvance = 0m;
if (taxableBase <= 0m)
{
taxAdvance = 0m;
}
else
{
if (period.Year() < 2013)
{
taxAdvance = FixTaxRoundUp(BigMulti(taxableBase, TaxAdvBracket1(year)));
}
else
{
decimal taxStandard = FixTaxRoundUp(BigMulti(taxableBase, TaxAdvBracket1(year)));
decimal maxSolBase = TaxSolBracketMax(year);
decimal effSolBase = Math.Max(0, taxableIncome - maxSolBase);
decimal taxSolidary = FixTaxRoundUp(BigMulti(effSolBase, TaxSolBracket(year)));
taxAdvance = taxStandard + taxSolidary;
}
}
return(taxAdvance);
}
PayrollProcess init_payroll_process(PayrollPeriod period)
{
PayTags = new PayTagGateway();
PayConcepts = new PayConceptGateway();
var payrollProcess = new PayrollProcess(PayTags, PayConcepts, period);
return(payrollProcess);
}
public ActionResult Create()
{
PayrollPeriod obj = new PayrollPeriod();
HelperMethod(obj);
return(View(obj));
}
public void InsertPayrollPeriod(PayrollPeriod payrollPeriod)
{
using (var db = new PayrollEntities())
{
db.PayrollPeriods.Add(payrollPeriod);
db.SaveChanges();
}
}
private SignificantProcessingDates GetDates(PayrollPeriod payrollPeriod)
{
return(new SignificantProcessingDates
{
DateOfCutoffForProcessing = _cutoffDatesService.GetDateTimeForProcessingCutoff(payrollPeriod),
DateOfCutoffForSubmission = _cutoffDatesService.GetDateTimeForSubmissionCutoff(payrollPeriod)
});
}
private decimal WithholdRoundedBase(PayrollPeriod period, bool isTaxDeclared, decimal taxableBase)
{
decimal amountForCalc = Math.Max(0, taxableBase);
decimal withholdBase = BigTaxRoundDown(amountForCalc);
return(withholdBase);
}
private decimal InsuranceContribution(PayrollPeriod period, decimal paymentIncome)
{
decimal pensionFactor = PensionSavingsFactor(period);
decimal contPaymentValue = FixInsuranceRoundUp(
BigMulti(paymentIncome, pensionFactor));
return(contPaymentValue);
}
public void ShouldReturnCorrectProcessingCutOffDate(short taxmonth, int expectedmonth, int expectedyear)
{
var payrollPeriod = new PayrollPeriod {
Year = "17-18", Month = taxmonth
};
var dateforprocessing = _cutoffdateservice.GetDateTimeForProcessingCutoff(payrollPeriod);
Assert.AreEqual(new DateTime(expectedyear, expectedmonth, 1).ToString("MM/YYYY"), dateforprocessing.ToString("MM/YYYY"));
}
public decimal InsuranceContribution(PayrollPeriod period, decimal paymentIncome, bool pensionPill)
{
decimal socialFactor = SocialInsuranceFactor(period, pensionPill);
decimal contPaymentValue = FixInsuranceRoundUp(
BigMulti(paymentIncome, socialFactor));
return(contPaymentValue);
}
private int[] MonthCalendarDays(PayrollPeriod period, int[] weekHours)
{
DateTime calendarBeg = new DateTime((int)period.Year(), (int)period.Month(), 1);
int calendarBegCwd = DayofWeekMondayToSunday(calendarBeg);
int dateCount = DateTime.DaysInMonth((int)period.Year(), (int)period.Month());
int[] hoursCalendar = Enumerable.Range(1, dateCount).Select((x) => (HoursFromWeek(weekHours, x, calendarBegCwd, calendarBeg))).ToArray();
return(hoursCalendar);
}
public override PayrollResult Evaluate(PayrollPeriod period, PayTagGateway tagConfig, IDictionary <TagRefer, PayrollResult> results)
{
var resultValues = new Dictionary <string, object>()
{
{ "hours", Hours }
};
return(new TermHoursResult(TagCode, Code, this, resultValues));
}
public ActionResult Delete(PayrollPeriod obj)
{
if (ModelState.IsValid)
{
PayrollPeriodService.PostDelete(obj);
return(Json("OK", JsonRequestBehavior.AllowGet));
}
HelperMethod(obj);
return(PartialView("Delete", obj));
}
public void Init()
{
PayPeriod = new PayrollPeriod(2013, 1);
PayTags = new PayTagGateway();
PayConcepts = new PayConceptGateway();
PayProcess = new PayrollProcess(PayTags, PayConcepts, PayPeriod);
}
public override PayrollResult Evaluate(PayrollPeriod period, PayTagGateway tagConfig, IDictionary <TagRefer, PayrollResult> results)
{
int[] hoursWeek = ComputeResultValue(period, HoursWeekly);
var resultValues = new Dictionary <string, object>()
{
{ "week_schedule", hoursWeek }
};
return(new ScheduleResult(TagCode, Code, this, resultValues));
}
public override PayrollResult Evaluate(PayrollPeriod period, PayTagGateway tagConfig, IDictionary <TagRefer, PayrollResult> results)
{
var resultIncome = ComputeResultValue(tagConfig, results);
var resultValues = new Dictionary <string, object>()
{
{ "amount", resultIncome }
};
return(new AmountResult(TagCode, Code, this, resultValues));
}
public decimal MaxAssesmentBase(PayrollPeriod period, decimal incomeBase)
{
decimal maximumBase = HealthMaxAssesment(period.Year());
if (maximumBase.Equals(0m))
{
return(incomeBase);
}
return(Math.Min(incomeBase, maximumBase));
}
public void GivenPayrollProcessForPayrollPeriod(string monthCode, string yearCode)
{
string monthParse = monthCode.TrimStart('0');
string yearParse = yearCode.TrimStart('0');
byte monthNumber = Byte.Parse(monthParse);
uint yearNumber = UInt32.Parse(yearParse);
PayPeriod = new PayrollPeriod(yearNumber, monthNumber);
my_payroll_process();
}
