Example #1
0
 private bool SaveLeaveQuotaYearEntry(float TotalLV, int LeaveTypeID, int EmpID, int FinancialYearID)
 {
     try
     {
         LeaveQuotaYear leaveQuotaYear = new LeaveQuotaYear();
         leaveQuotaYear.EmployeeID      = EmpID;
         leaveQuotaYear.CFFromLastYear  = 0;
         leaveQuotaYear.FinancialYearID = FinancialYearID;
         leaveQuotaYear.GrandRemaining  = TotalLV;
         leaveQuotaYear.GrandTotal      = TotalLV;
         leaveQuotaYear.LeaveTypeID     = (byte)LeaveTypeID;
         leaveQuotaYear.YearlyRemaining = TotalLV;
         leaveQuotaYear.YearlyTotal     = TotalLV;
         LeaveQuotaYearReporsitory.Add(leaveQuotaYear);
         LeaveQuotaYearReporsitory.Save();
         return(true);
     }
     catch (Exception ex)
     {
         return(false);
     }
 }
        public ActionResult Create(DailyOvertime obj)
        {
            string _EmpNo = Request.Form["EmpNo"].ToString();
            Expression <Func <VHR_EmployeeProfile, bool> > SpecificEntries121 = c => c.OEmpID == _EmpNo;
            VMLoggedUser LoggedInUser       = Session["LoggedInUser"] as VMLoggedUser;
            List <VHR_EmployeeProfile> _emp = vHR_EmployeeProfile.GetIndexSpecific(SpecificEntries121);

            if (obj.OTDate == null || obj.OTDate <= DateTime.Today.AddDays(-200))
            {
                ModelState.AddModelError("OTDate", "OT Date must be valid");
            }
            else
            {
                if (!DDService.IsDateLieBetweenActivePayroll(obj.OTDate.Value))
                {
                    ModelState.AddModelError("OTDate", "Payroll Period is Closed for this date");
                }
            }
            if ((obj.SingleEncashableOT == null && obj.SingleEncashableOT <= 0) && (obj.DoubleEncashbaleOT == null && obj.DoubleEncashbaleOT <= 0) && (obj.CPLOT == null && obj.CPLOT <= 0))
            {
                ModelState.AddModelError("SingleEncashableOT", "Overtime must be valid");
            }
            if (_emp.Count == 0)
            {
                ModelState.AddModelError("OTDate", "Emp No not exist");
            }
            else
            {
                // int? EmpLocID = _emp.First().LocationID;
                //if (LoggedInUser.UserLoctions.Where(aa => aa.LocationID == EmpLocID).Count() == 0)
                //ModelState.AddModelError("OTDate", "You do not have rights to add overtime for this employee");
                int?EmpDepID = _emp.First().OUCommonID;
                if (LoggedInUser.UserDepartments.Where(aa => aa.DepartmentID == EmpDepID).Count() == 0)
                {
                    ModelState.AddModelError("OTDate", "You do not have rights to add overtime for this employee");
                }
                obj.EmployeeID = _emp.First().PEmployeeID;
                Expression <Func <DailyOvertime, bool> > SpecificEntries2 = c => c.EmployeeID == obj.EmployeeID && c.OTDate == obj.OTDate;
                if (DailyOvertimeService.GetIndexSpecific(SpecificEntries2).Count > 0)
                {
                    ModelState.AddModelError("OTDate", "Already have OT for this date");
                }
            }

            if (ModelState.IsValid)
            {
                if (obj.SingleEncashableOT > 0)
                {
                    obj.SingleEncashableOT = obj.SingleEncashableOT * 60;
                }
                if (obj.DoubleEncashbaleOT > 0)
                {
                    obj.DoubleEncashbaleOT = obj.DoubleEncashbaleOT * 60;
                }
                if (obj.CPLOT > 0)
                {
                    obj.CPLOT = obj.CPLOT * 60;
                }
                obj.AddedByUserID = LoggedInUser.PUserID;
                obj.AddedDate     = DateTime.Now;
                DailyOvertimeService.PostCreate(obj);
                // Update Attendance Data
                Expression <Func <DailyAttendance, bool> > SpecificEntries2 = c => c.EmpID == obj.EmployeeID && c.AttDate == obj.OTDate;
                List <DailyAttendance> attDatas = DailyAttendanceService.GetIndexSpecific(SpecificEntries2).ToList();
                if (attDatas.Count > 0)
                {
                    DailyAttendance attdata = attDatas.First();
                    if (obj.SingleEncashableOT > 0)
                    {
                        attdata.ApprovedOT = (short)obj.SingleEncashableOT;
                    }
                    if (obj.DoubleEncashbaleOT > 0)
                    {
                        attdata.ApprovedDoubleOT = (short)obj.DoubleEncashbaleOT;
                    }
                    if (obj.CPLOT > 0)
                    {
                        attdata.ApprovedCPL = (short)obj.CPLOT;
                    }
                    DailyAttendanceService.PostEdit(attdata);
                    DDService.ProcessMonthlyAttendance((DateTime)obj.OTDate, (int)obj.EmployeeID, obj.EmployeeID.ToString());
                    // Update Employee Pool
                    LeaveCPLPool dbLeavePoolCPL = new LeaveCPLPool();
                    Expression <Func <LeaveCPLPool, bool> > SpecificEntries3 = c => c.EmployeeID == obj.EmployeeID;

                    if (LeaveCPLPoolService.GetIndexSpecific(SpecificEntries3).Count() > 0)
                    {
                        dbLeavePoolCPL = LeaveCPLPoolService.GetIndexSpecific(SpecificEntries3).First();
                        dbLeavePoolCPL.LastEntryDateTime = DateTime.Now;
                        dbLeavePoolCPL.RemainingHours    = dbLeavePoolCPL.RemainingHours + (obj.CPLOT / 60);
                        if (dbLeavePoolCPL.RemainingHours == null)
                        {
                            dbLeavePoolCPL.RemainingHours = 0;
                            dbLeavePoolCPL.RemainingHours = (dbLeavePoolCPL.RemainingHours) + (obj.CPLOT / 60);
                        }
                        dbLeavePoolCPL.TotalHours = (dbLeavePoolCPL.TotalHours) + (obj.CPLOT / 60);
                        if (dbLeavePoolCPL.TotalHours == null)
                        {
                            dbLeavePoolCPL.TotalHours = 0;
                            dbLeavePoolCPL.TotalHours = (dbLeavePoolCPL.TotalHours) + (obj.CPLOT / 60);
                        }
                        dbLeavePoolCPL.CPLDays = 0;
                        LeaveCPLPoolService.PostEdit(dbLeavePoolCPL);
                    }
                    else
                    {
                        dbLeavePoolCPL                   = new LeaveCPLPool();
                        dbLeavePoolCPL.EmployeeID        = obj.EmployeeID;
                        dbLeavePoolCPL.LastEntryDateTime = DateTime.Now;
                        dbLeavePoolCPL.RemainingHours    = obj.CPLOT / 60;
                        dbLeavePoolCPL.TotalHours        = obj.CPLOT / 60;
                        dbLeavePoolCPL.CPLDays           = 0;
                        LeaveCPLPoolService.PostCreate(dbLeavePoolCPL);
                    }
                    // Update CPL
                    if (dbLeavePoolCPL.RemainingHours >= 4)
                    {
                        int   total     = (int)(dbLeavePoolCPL.RemainingHours / 4);
                        float remaining = (float)(dbLeavePoolCPL.RemainingHours - (total * 4));
                        float days      = (float)(total / 2.0);
                        // Add into CPL Balance
                        LeaveCPLEmpBalance dbLeaveBalanceCPL = new LeaveCPLEmpBalance();
                        dbLeaveBalanceCPL.EmployeeID    = obj.EmployeeID;
                        dbLeaveBalanceCPL.EntryDateTime = DateTime.Now;
                        dbLeaveBalanceCPL.ExpireDate    = DateTime.Today.AddDays(60);
                        dbLeaveBalanceCPL.IsExpire      = false;
                        dbLeaveBalanceCPL.RemainingDays = days;
                        dbLeaveBalanceCPL.TotalDays     = days;
                        dbLeaveBalanceCPL.Used          = 0;
                        LeaveCPLEmpBalanceService.PostCreate(dbLeaveBalanceCPL);
                        // update CPL Pool
                        dbLeavePoolCPL.RemainingHours = dbLeavePoolCPL.RemainingHours - (days * 8);
                        //dbLeavePoolCPL.RemainingHours = dbLeavePoolCPL.RemainingHours + remaining;
                        LeaveCPLPoolService.PostEdit(dbLeavePoolCPL);
                        // Get PayrollPeriod
                        PayrollPeriod dbPayrollPeriod = ATAssistant.GetPayrollPeriodObject(obj.OTDate.Value, DDService.GetAllPayrollPeriod());
                        // Update Days in Leave Quota
                        LeaveQuotaYear dbLeaveQuotaYear = new LeaveQuotaYear();
                        Expression <Func <LeaveQuotaYear, bool> > SpecificEntries4 = c => c.FinancialYearID == dbPayrollPeriod.FinancialYearID && c.EmployeeID == obj.EmployeeID && c.LeaveTypeID == 4;
                        if (LeaveQuotaYearService.GetIndexSpecific(SpecificEntries4).Count > 0)
                        {
                            dbLeaveQuotaYear                 = LeaveQuotaYearService.GetIndexSpecific(SpecificEntries4).First();
                            dbLeaveQuotaYear.GrandTotal      = dbLeaveQuotaYear.GrandTotal + days;
                            dbLeaveQuotaYear.GrandRemaining  = dbLeaveQuotaYear.GrandRemaining + days;
                            dbLeaveQuotaYear.YearlyTotal     = dbLeaveQuotaYear.YearlyTotal + days;
                            dbLeaveQuotaYear.YearlyRemaining = dbLeaveQuotaYear.YearlyRemaining + days;
                            LeaveQuotaYearService.PostEdit(dbLeaveQuotaYear);
                        }
                        else
                        {
                            dbLeaveQuotaYear.EmployeeID      = obj.EmployeeID;
                            dbLeaveQuotaYear.FinancialYearID = dbPayrollPeriod.FinancialYearID;
                            dbLeaveQuotaYear.LeaveTypeID     = 4;
                            dbLeaveQuotaYear.GrandTotal      = 0;
                            dbLeaveQuotaYear.GrandRemaining  = 0;
                            dbLeaveQuotaYear.YearlyTotal     = 0;
                            dbLeaveQuotaYear.YearlyRemaining = 0;
                            dbLeaveQuotaYear.GrandTotal      = dbLeaveQuotaYear.GrandTotal + days;
                            dbLeaveQuotaYear.GrandRemaining  = dbLeaveQuotaYear.GrandRemaining + days;
                            dbLeaveQuotaYear.YearlyTotal     = dbLeaveQuotaYear.YearlyTotal + days;
                            dbLeaveQuotaYear.YearlyRemaining = dbLeaveQuotaYear.YearlyRemaining + days;
                            LeaveQuotaYearService.PostCreate(dbLeaveQuotaYear);
                        }
                    }
                }
                //DDService.SaveAuditLog(LoggedInUser.PUserID, AuditFormAttendance.Crew, AuditTypeCommon.Add, obj.PDailyOTID, App_Start.AppAssistant.GetClientMachineInfo());
                return(Json("OK", JsonRequestBehavior.AllowGet));
            }
            return(PartialView("Create", obj));
        }
        public List <VMLeaveBalance> GetYearlyLeaveBalance(List <VHR_EmployeeProfile> dbEmps, int FinancialYearID)
        {
            Expression <Func <LeaveQuotaYear, bool> > SpecificEntries = c => c.FinancialYearID == FinancialYearID;
            List <LeaveQuotaYear> dbLeaveQuotaYears = LeaveQuotaYearRepository.FindBy(SpecificEntries);
            Expression <Func <FinancialYear, bool> > SpecificFinancialYear = c => c.PFinancialYearID == FinancialYearID;
            FinancialYear         dbFinancialYear    = FinancialYearRepository.FindBy(SpecificFinancialYear).First();
            List <VMLeaveBalance> vmLeaveBalanceList = new List <VMLeaveBalance>();

            foreach (var dbEmp in dbEmps)
            {
                VMLeaveBalance vmLeaveBalance = new VMLeaveBalance();

                vmLeaveBalance.PEmployeeID  = dbEmp.PEmployeeID;
                vmLeaveBalance.OEmpID       = dbEmp.OEmpID;
                vmLeaveBalance.EmployeeName = dbEmp.EmployeeName;
                //vmLeaveBalance.OUName = dbEmp.OUName;
                vmLeaveBalance.LocationName       = dbEmp.LocationName;
                vmLeaveBalance.JobTitleName       = dbEmp.JobTitleName;
                vmLeaveBalance.EmploymentTypeName = dbEmp.EmploymentTypeName;
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 1).Count() > 0) // AL
                {
                    LeaveQuotaYear dbLeaveQuotaYear = dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 1).First();
                    vmLeaveBalance.TotalAL   = dbLeaveQuotaYear.YearlyTotal;
                    vmLeaveBalance.BalanceAL = dbLeaveQuotaYear.YearlyRemaining;
                    vmLeaveBalance.AvailAL   = vmLeaveBalance.TotalAL - vmLeaveBalance.BalanceAL;
                }
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 1).Count() > 0) // ACCU
                {
                    LeaveQuotaYear dbLeaveQuotaYear = dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 1).First();
                    vmLeaveBalance.TotalAccum   = dbLeaveQuotaYear.CFFromLastYear;
                    vmLeaveBalance.BalanceAccum = dbLeaveQuotaYear.CFRemaining;
                    vmLeaveBalance.AvailAccum   = vmLeaveBalance.TotalAccum - vmLeaveBalance.BalanceAccum;
                }
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 2).Count() > 0) // CL
                {
                    LeaveQuotaYear dbLeaveQuotaYear = dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 2).First();
                    vmLeaveBalance.TotalCL   = dbLeaveQuotaYear.YearlyTotal;
                    vmLeaveBalance.BalanceCL = dbLeaveQuotaYear.YearlyRemaining;
                    vmLeaveBalance.AvailCL   = vmLeaveBalance.TotalCL - vmLeaveBalance.BalanceCL;
                }
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 3).Count() > 0) //SL
                {
                    LeaveQuotaYear dbLeaveQuotaYear = dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 3).First();
                    vmLeaveBalance.TotalSL   = dbLeaveQuotaYear.YearlyTotal;
                    vmLeaveBalance.BalanceSL = dbLeaveQuotaYear.YearlyRemaining;
                    vmLeaveBalance.AvailSL   = vmLeaveBalance.TotalSL - vmLeaveBalance.BalanceSL;
                }
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 4).Count() > 0) //CPL
                {
                    LeaveQuotaYear dbLeaveQuotaYear = dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 4).First();
                    vmLeaveBalance.TotalCPL   = dbLeaveQuotaYear.YearlyTotal;
                    vmLeaveBalance.BalanceCPL = dbLeaveQuotaYear.YearlyRemaining;
                    vmLeaveBalance.AvailCPL   = vmLeaveBalance.TotalCPL - vmLeaveBalance.BalanceCPL;
                }
                Expression <Func <LeaveData, bool> > SpecificEntries99 = c => c.LeaveTypeID == 9 && c.EmpID == dbEmp.PEmployeeID;
                List <LeaveData> dbLeaveDatas = LeaveDataRepository.FindBy(SpecificEntries99);
                vmLeaveBalance.AvailHajjLeaves = dbLeaveDatas.Where(aa => aa.EmpID == dbEmp.PEmployeeID && aa.HalfLeave == false && aa.LeaveTypeID == 9).Count() + (dbLeaveDatas.Where(aa => aa.HalfLeave == true && aa.EmpID == dbEmp.PEmployeeID && aa.LeaveTypeID == 9).Count() / 2);

                vmLeaveBalanceList.Add(vmLeaveBalance);
            }



            return(vmLeaveBalanceList);
        }
        public List <VMMonthlyLeaveBalance> GetMonthlyLeaveBalance(List <VHR_EmployeeProfile> dbEmps, int FinancialYearID, DateTime StartDate, DateTime EndDate)
        {
            Expression <Func <LeaveData, bool> > SpecificEntries = c => c.AttDate >= StartDate && c.AttDate <= EndDate;
            List <LeaveData> dbLeaveDatas = LeaveDataRepository.FindBy(SpecificEntries);
            Expression <Func <LeaveQuotaYear, bool> > SpecificEntries2 = c => c.FinancialYearID == FinancialYearID;
            List <LeaveQuotaYear>        dbLeaveQuotaYears             = LeaveQuotaYearRepository.FindBy(SpecificEntries2);
            List <VMMonthlyLeaveBalance> vmMonthlyLeaveBalanceList     = new List <VMMonthlyLeaveBalance>();

            foreach (var dbEmp in dbEmps)
            {
                VMMonthlyLeaveBalance vmMonthlyLeaveBalance = new VMMonthlyLeaveBalance();

                vmMonthlyLeaveBalance.EmpID        = dbEmp.PEmployeeID;
                vmMonthlyLeaveBalance.OEmpID       = dbEmp.OEmpID;
                vmMonthlyLeaveBalance.EmployeeName = dbEmp.EmployeeName;
                vmMonthlyLeaveBalance.LocationName = dbEmp.LocationName;
                //vmMonthlyLeaveBalance.OUName = dbEmp.OUName;
                vmMonthlyLeaveBalance.JobTitleName = dbEmp.JobTitleName;
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 1).Count() > 0) // AL
                {
                    LeaveQuotaYear dbLeaveQuotaYear = dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 1).First();
                    vmMonthlyLeaveBalance.BalanceAL = dbLeaveQuotaYear.YearlyRemaining;
                    vmMonthlyLeaveBalance.AvailedAL = dbLeaveDatas.Where(aa => aa.EmpID == dbEmp.PEmployeeID && aa.HalfLeave == false && (aa.IsAccum == false || aa.IsAccum == null) && aa.LeaveTypeID == 1).Count() + (dbLeaveDatas.Where(aa => aa.HalfLeave == true && (aa.IsAccum == false || aa.IsAccum == null) && aa.EmpID == dbEmp.PEmployeeID && aa.LeaveTypeID == 1).Count() / 2);
                }
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 1).Count() > 0) // ACCU
                {
                    LeaveQuotaYear dbLeaveQuotaYear = dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 1).First();
                    vmMonthlyLeaveBalance.BalanceAccum = dbLeaveQuotaYear.CFRemaining;
                    vmMonthlyLeaveBalance.AvailedAccum = dbLeaveDatas.Where(aa => aa.EmpID == dbEmp.PEmployeeID && aa.HalfLeave == false && aa.IsAccum == true && aa.LeaveTypeID == 1).Count() + (dbLeaveDatas.Where(aa => aa.HalfLeave == true && aa.IsAccum == true && aa.EmpID == dbEmp.PEmployeeID && aa.LeaveTypeID == 1).Count() / 2);
                }
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 2).Count() > 0) // CL
                {
                    LeaveQuotaYear dbLeaveQuotaYear = dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 2).First();
                    vmMonthlyLeaveBalance.BalanceCL = dbLeaveQuotaYear.YearlyRemaining;
                    vmMonthlyLeaveBalance.AvailedCL = dbLeaveDatas.Where(aa => aa.EmpID == dbEmp.PEmployeeID && aa.HalfLeave == false && aa.LeaveTypeID == 2).Count() + (dbLeaveDatas.Where(aa => aa.HalfLeave == true && aa.EmpID == dbEmp.PEmployeeID && aa.LeaveTypeID == 2).Count() / 2);
                }
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 3).Count() > 0) //SL
                {
                    LeaveQuotaYear dbLeaveQuotaYear = dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 3).First();
                    vmMonthlyLeaveBalance.BalanceSL = dbLeaveQuotaYear.YearlyRemaining;
                    vmMonthlyLeaveBalance.AvailedSL = dbLeaveDatas.Where(aa => aa.EmpID == dbEmp.PEmployeeID && aa.HalfLeave == false && aa.LeaveTypeID == 3).Count() + (dbLeaveDatas.Where(aa => aa.HalfLeave == true && aa.EmpID == dbEmp.PEmployeeID && aa.LeaveTypeID == 3).Count() / 2);
                }
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 4).Count() > 0) //CPL
                {
                    LeaveQuotaYear dbLeaveQuotaYear = dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 4).First();
                    vmMonthlyLeaveBalance.BalanceCPL = dbLeaveQuotaYear.YearlyRemaining;
                    vmMonthlyLeaveBalance.AvailedCPL = dbLeaveDatas.Where(aa => aa.EmpID == dbEmp.PEmployeeID && aa.HalfLeave == false && aa.LeaveTypeID == 4).Count() + (dbLeaveDatas.Where(aa => aa.HalfLeave == true && aa.EmpID == dbEmp.PEmployeeID && aa.LeaveTypeID == 4).Count() / 2);
                }
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 5).Count() >= 0) //LWOP
                {
                    vmMonthlyLeaveBalance.AvailedLWOP = dbLeaveDatas.Where(aa => aa.EmpID == dbEmp.PEmployeeID && aa.HalfLeave == false && aa.LeaveTypeID == 5).Count() + (dbLeaveDatas.Where(aa => aa.HalfLeave == true && aa.EmpID == dbEmp.PEmployeeID && aa.LeaveTypeID == 5).Count() / 2);
                }

                vmMonthlyLeaveBalance.AvailedSpecialLeave = dbLeaveDatas.Where(aa => aa.EmpID == dbEmp.PEmployeeID && aa.HalfLeave == false && aa.LeaveTypeID == 6).Count() + (dbLeaveDatas.Where(aa => aa.HalfLeave == true && aa.EmpID == dbEmp.PEmployeeID && aa.LeaveTypeID == 6).Count() / 2);


                vmMonthlyLeaveBalance.AvailedPaternity = dbLeaveDatas.Where(aa => aa.EmpID == dbEmp.PEmployeeID && aa.HalfLeave == false && aa.LeaveTypeID == 7).Count() + (dbLeaveDatas.Where(aa => aa.HalfLeave == true && aa.EmpID == dbEmp.PEmployeeID && aa.LeaveTypeID == 7).Count() / 2);


                vmMonthlyLeaveBalance.AvailedMaternity = dbLeaveDatas.Where(aa => aa.EmpID == dbEmp.PEmployeeID && aa.HalfLeave == false && aa.LeaveTypeID == 8).Count() + (dbLeaveDatas.Where(aa => aa.HalfLeave == true && aa.EmpID == dbEmp.PEmployeeID && aa.LeaveTypeID == 8).Count() / 2);


                vmMonthlyLeaveBalance.AvailedHajjLeaves = dbLeaveDatas.Where(aa => aa.EmpID == dbEmp.PEmployeeID && aa.HalfLeave == false && aa.LeaveTypeID == 9).Count() + (dbLeaveDatas.Where(aa => aa.HalfLeave == true && aa.EmpID == dbEmp.PEmployeeID && aa.LeaveTypeID == 9).Count() / 2);

                vmMonthlyLeaveBalanceList.Add(vmMonthlyLeaveBalance);
            }



            return(vmMonthlyLeaveBalanceList);
        }
Example #5
0
        public static List <VMLeaveBalance> GetYearlyLeaveBalance(List <VHR_EmployeeProfile> dbEmps, FinancialYear dbFinYear, List <LeaveQuotaYear> dbLeaveQuotaYears, List <LeavePolicy> dbLeavePolicies,
                                                                  List <LeaveData> dbLeaveDatas, ABESSPEntities db)
        {
            List <VMLeaveBalance> vmLeaveBalanceList = new List <VMLeaveBalance>();

            foreach (var dbEmp in dbEmps)
            {
                float          TotalLvDays    = 21;
                VMLeaveBalance vmLeaveBalance = new VMLeaveBalance();
                if (dbEmp.ALPolicyID != null && dbLeavePolicies.Where(aa => aa.PLeavePolicyID == dbEmp.ALPolicyID).Count() > 0)
                {
                    TotalLvDays = (float)dbLeavePolicies.First(aa => aa.PLeavePolicyID == dbEmp.ALPolicyID).TotalDays;
                }
                vmLeaveBalance.PEmployeeID   = dbEmp.PEmployeeID;
                vmLeaveBalance.EmployeeName  = dbEmp.EmployeeName;
                vmLeaveBalance.DOJ           = dbEmp.DOJ;
                vmLeaveBalance.ServiceLength = GetServiceLength(dbEmp.DOJ, dbEmp.ResignDate);
                if (dbEmp.Status == "Resigned")
                {
                    vmLeaveBalance.OEmpID = dbEmp.OEmpID + " (Resigned Date: " + dbEmp.ResignDate.Value.ToString("dd-MM-yyyy") + ")";
                    int PayrollPeriodIDEnd      = ATAssistant.GetPayrollPeriodIDEnd(dbEmp.ResignDate.Value, db.PayrollPeriods.ToList());
                    List <MonthData> monthDatas = db.MonthDatas.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.AbsentDays > 0).ToList();
                    if (monthDatas.Count() > 0)
                    {
                        vmLeaveBalance.Absents = (float)monthDatas.Sum(aa => aa.AbsentDays);
                    }
                }
                else
                {
                    vmLeaveBalance.OEmpID = dbEmp.OEmpID;
                }
                // vmLeaveBalance.OUName = dbEmp.OUName;
                vmLeaveBalance.LocationName       = dbEmp.LocationName;
                vmLeaveBalance.JobTitleName       = dbEmp.JobTitleName;
                vmLeaveBalance.EmploymentTypeName = dbEmp.EmploymentTypeName;
                vmLeaveBalance.LWOP = dbLeaveDatas.Where(aa => aa.EmpID == dbEmp.PEmployeeID && aa.HalfLeave == false).Count() + (dbLeaveDatas.Where(aa => aa.EmpID == dbEmp.PEmployeeID && aa.HalfLeave == true).Count() / 2);
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 1).Count() > 0) // AL
                {
                    LeaveQuotaYear dbLeaveQuotaYear = dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 1).First();
                    vmLeaveBalance.TotalAL   = dbLeaveQuotaYear.YearlyTotal;
                    vmLeaveBalance.BalanceAL = dbLeaveQuotaYear.YearlyRemaining;
                    vmLeaveBalance.AvailAL   = vmLeaveBalance.TotalAL - vmLeaveBalance.BalanceAL;
                    if (dbEmp.Status == "Resigned")
                    {
                        // Check for if employee join in same financial year
                        float Divider     = 1;
                        float WorkingDays = 0;
                        if (dbEmp.DOJ.Value >= dbFinYear.FYStartDate)
                        {
                            Divider     = (dbFinYear.FYEndDate.Value - dbEmp.DOJ.Value).Days + 1;
                            WorkingDays = (dbEmp.ResignDate.Value - dbEmp.DOJ.Value).Days + 1;
                        }
                        else
                        {
                            Divider     = 365;
                            WorkingDays = (dbEmp.ResignDate.Value - dbFinYear.FYStartDate.Value).Days + 1;
                        }
                        float  ProRataLeave = (float)(vmLeaveBalance.TotalAL * WorkingDays) / Divider;
                        double decimalValue = Math.Round((double)ProRataLeave, 1);
                        vmLeaveBalance.ProrataAL = decimalValue;
                    }
                }
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 1).Count() > 0) // ACCU
                {
                    LeaveQuotaYear dbLeaveQuotaYear = dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 1).First();
                    vmLeaveBalance.TotalAccum   = dbLeaveQuotaYear.CFFromLastYear;
                    vmLeaveBalance.BalanceAccum = dbLeaveQuotaYear.CFRemaining;
                    vmLeaveBalance.AvailAccum   = vmLeaveBalance.TotalAccum - vmLeaveBalance.BalanceAccum;
                    vmLeaveBalance.ProrataAccum = vmLeaveBalance.BalanceAccum;
                }
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 2).Count() > 0) // CL
                {
                    LeaveQuotaYear dbLeaveQuotaYear = dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 2).First();
                    vmLeaveBalance.TotalCL   = dbLeaveQuotaYear.YearlyTotal;
                    vmLeaveBalance.BalanceCL = dbLeaveQuotaYear.YearlyRemaining;
                    vmLeaveBalance.AvailCL   = vmLeaveBalance.TotalCL - vmLeaveBalance.BalanceCL;
                }
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 3).Count() > 0) //SL
                {
                    LeaveQuotaYear dbLeaveQuotaYear = dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 3).First();
                    vmLeaveBalance.TotalSL   = dbLeaveQuotaYear.YearlyTotal;
                    vmLeaveBalance.BalanceSL = dbLeaveQuotaYear.YearlyRemaining;
                    vmLeaveBalance.AvailSL   = vmLeaveBalance.TotalSL - vmLeaveBalance.BalanceSL;
                }
                if (dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 4).Count() > 0) //CPL
                {
                    LeaveQuotaYear dbLeaveQuotaYear = dbLeaveQuotaYears.Where(aa => aa.EmployeeID == dbEmp.PEmployeeID && aa.LeaveTypeID == 4).First();
                    vmLeaveBalance.TotalCPL   = dbLeaveQuotaYear.YearlyTotal;
                    vmLeaveBalance.BalanceCPL = dbLeaveQuotaYear.YearlyRemaining;
                    vmLeaveBalance.AvailCPL   = vmLeaveBalance.TotalCPL - vmLeaveBalance.BalanceCPL;
                }
                vmLeaveBalanceList.Add(vmLeaveBalance);
            }



            return(vmLeaveBalanceList);
        }