コード例 #1
0
ファイル: frmEmployeePayslip.cs プロジェクト: ewin66/RAPH
        public override void SaveRecord(SavingParemeter Paras)
        {
            int MonthFrom  = DateFrom.Month;
            int YearFrom   = DateFrom.Year;
            int EmployeeID = (int)lookupEmployee.EditValue;

            tblPayrollEmployeeDetail EmployeeDetailSaveModel = null;

            if (EditingEmployeeDetail != null && EditingEmployeeDetail.PayrollEmployeeDetailID != 0)
            {
                EmployeeDetailSaveModel = DALObj.FindPayrollEmployeeDetailByID(EditingEmployeeDetail.PayrollEmployeeDetailID);
            }
            if (EmployeeDetailSaveModel == null)
            {
                EmployeeDetailSaveModel = new tblPayrollEmployeeDetail();
            }

            EmployeeDetailSaveModel.EmployeeID          = EmployeeID;
            EmployeeDetailSaveModel.NormalOvertimeHours = NormalOvertimeHours;
            EmployeeDetailSaveModel.DoubleOvertimeHours = DoubleOvertimeHours;
            EmployeeDetailSaveModel.AbsentDays          = AbsentDays;
            EmployeeDetailSaveModel.WeekendWorkedDays   = WeekendWorkedDays;
            EmployeeDetailSaveModel.LeaveEncashmentDays = LeaveEncashmentDays;
            EmployeeDetailSaveModel.NoticePayDays       = NoticePayDay;

            EmployeeDetailSaveModel.LateDays = LatenessDays;
            EmployeeDetailSaveModel.LoanInstallmentAmount = LoanInstallmentAmt;

            EmployeeDetailSaveModel.Vehicle_NoncashBenefitID = (int?)lookUpVehicle_NonCashBenefit.EditValue;
            if (EmployeeDetailSaveModel.Vehicle_NoncashBenefitID == -1)
            {
                EmployeeDetailSaveModel.Vehicle_NoncashBenefitID = null;
            }

            Paras.SavingResult = DALObj.SavePayroll(DateFrom.Month, DateFrom.Year, EmployeeDetailSaveModel, dsEarningAndDeduction, dsNonCashBenefit, dsPAYERelief);
            base.SaveRecord(Paras);
        }
コード例 #2
0
ファイル: frmEmployeePayslip.cs プロジェクト: ewin66/RAPH
        void GetPaySlipData(int EmployeeID)
        {
            ClearPayrollValues();
            //--
            EmployeeSaveModel = EmployeeDALObj.FindSaveModelByPrimeKey(EmployeeID);
            if (EmployeeSaveModel == null)
            {
                return;
            }

            ServiceSaveModel = EmployeeSaveModel.tblEmployeeServiceDetail;
            if (ServiceSaveModel == null)
            {
                return;
            }

            BasicIncome        = ServiceSaveModel.BasicSalary;
            txtIncomeType.Text = (EmployeeSaveModel.IncomeType ? "Primary" : "Secondry") + " Income";
            HRA = ServiceSaveModel.HousingAllowance;

            NormalOvertimeRatio = CommonProperties.LoginInfo.SoftwareSettings.OvertimeRate;
            DoubleOvertimeRatio = CommonProperties.LoginInfo.SoftwareSettings.DoubleOvertimeRate;

            decimal GrossPay             = BasicIncome + HRA;
            decimal WorkingHoursPerMonth = ((CommonProperties.LoginInfo.SoftwareSettings.WorkingHoursPerWeek * 52) / 12);

            BasicPayRatePerHour = Math.Round(BasicIncome / WorkingHoursPerMonth, 2);
            BasicPayRatePerDay  = Math.Round((BasicIncome / WorkingHoursPerMonth) * CommonProperties.LoginInfo.SoftwareSettings.WorkingHoursPerDay, 2);

            GrossPayRatePerHour = Math.Round(GrossPay / WorkingHoursPerMonth, 2);
            GrossPayRatePerDay  = Math.Round((GrossPay / WorkingHoursPerMonth) * CommonProperties.LoginInfo.SoftwareSettings.WorkingHoursPerDay, 2);

            LatenessRatePerDay = Model.CommonProperties.LoginInfo.SoftwareSettings.LatenessPenaltyAmount;

            EditingEmployeeDetail = DALObj.FindPayrollEmployeeDetail(DateFrom.Month, DateFrom.Year, EmployeeSaveModel.EmployeeID);
            if (EditingEmployeeDetail != null)
            {
                #region Fill saved data in form
                NormalOvertimeHours = EditingEmployeeDetail.NormalOvertimeHours;
                DoubleOvertimeHours = EditingEmployeeDetail.DoubleOvertimeHours;
                AbsentDays          = EditingEmployeeDetail.AbsentDays;

                AbsentDays += EditingEmployeeDetail.MissedPunchDays;

                WeekendWorkedDays   = EditingEmployeeDetail.WeekendWorkedDays;
                LeaveEncashmentDays = EditingEmployeeDetail.LeaveEncashmentDays;
                NoticePayDay        = EditingEmployeeDetail.NoticePayDays;

                LatenessDays       = EditingEmployeeDetail.LateDays;
                LoanInstallmentAmt = EditingEmployeeDetail.LoanInstallmentAmount;
                lookUpVehicle_NonCashBenefit.EditValue = EditingEmployeeDetail.Vehicle_NoncashBenefitID;

                foreach (var r in EditingEmployeeDetail.tblPayrollEmployeeEarningsDeductions)
                {
                    var ViewModel = dsEarningAndDeduction.FirstOrDefault(rr => rr.EarningAndDeductionID == r.EarningsDeductionID && r.Value != 0);
                    if (ViewModel != null)
                    {
                        ViewModel.Value = r.Value;
                    }
                }
                gvEarnings.RefreshData();
                gvDeductions.RefreshData();

                foreach (var r in EditingEmployeeDetail.tblPayrollEmployeeNonCashBenefits)
                {
                    var ViewModel = dsNonCashBenefit.FirstOrDefault(rr => rr.NonCashBenefitID == r.NonCashBenefitID);
                    if (ViewModel != null)
                    {
                        ViewModel.Selected           = true;
                        ViewModel.CostValue          = r.CostValue;
                        ViewModel.KRAValuePercentage = r.KRAPerc;
                        ViewModel.KRAValue           = r.KRAValue;
                        ViewModel.Recurrning         = r.Recurring;
                    }
                }
                gvNonCashBenefit.RefreshData();

                foreach (var r in EditingEmployeeDetail.tblPayrollEmployePAYEReliefs)
                {
                    var ViewModel = dsPAYERelief.FirstOrDefault(rr => rr.PAYEReliefID == r.PAYEReliefID && r.PAYEReliefAmt != 0);
                    if (ViewModel != null)
                    {
                        ViewModel.Selected      = true;
                        ViewModel.PAYEReliefAmt = r.PAYEReliefAmt;
                    }
                }
                #endregion
            }
            else if (((eTAAttendanceType)EmployeeSaveModel.TAAttendanceType) == eTAAttendanceType.Integrated)
            {
                #region Processing Attendance Data
                Model.Employee.eTAAttendanceType AttendanceType = ((Model.Employee.eTAAttendanceType)EmployeeSaveModel.TAAttendanceType);

                if (AttendanceType == eTAAttendanceType.Integrated)
                {
                    EmployeeAttendanceDAL AttendanceDALObj = new EmployeeAttendanceDAL();
                    var dsAttendance = AttendanceDALObj.GetEmployeeAttendanceData(DateFrom, DateTo, EmployeeSaveModel.EmployeeID);

                    #region Earnings
                    NormalOvertimeHours = Math.Round(dsAttendance.Sum(r => r.NormalOvertimeHour), 2);

                    if (((Model.Employee.eTAWeekEndAttendance)EmployeeSaveModel.TAWeekEndAttendance) == Model.Employee.eTAWeekEndAttendance.Overtime)
                    {
                        DoubleOvertimeHours = Math.Round(dsAttendance.Sum(r => r.DoubleOvertimeHour), 2);
                    }

                    if (((Model.Employee.eTAWeekEndAttendance)EmployeeSaveModel.TAWeekEndAttendance) == Model.Employee.eTAWeekEndAttendance.Allowance)
                    {
                        // Round off not required, if weekend worked then whole day will be counted as worked.
                        WeekendWorkedDays = dsAttendance.Count(r =>
                                                               ((r.Weekend == eEmployeeWeekendDayType.WeekendWorked && r.WeekendWorkedApproved) ||
                                                                (r.RestDay == eEmployeeRestDayDayType.RestDayWorked || r.RestDayWorkedApproved)) && (((eTAMissPunch)EmployeeSaveModel.TAMissPunch) == eTAMissPunch.Present || !r.MissedPunch));
                    }

                    LeaveEncashmentDays = DALObj.CountLeaveEncashmentDays(EmployeeSaveModel.EmployeeID, DateFrom, DateTo);
                    #endregion

                    #region Deductions
                    AbsentDays = dsAttendance.Sum(r => r.AbsentCount);

                    if (((eTAMissPunch)EmployeeSaveModel.TAMissPunch) == eTAMissPunch.Abscent)
                    {
                        AbsentDays += dsAttendance.Count(r => r.MissedPunch);
                    }

                    if (((Model.Employee.eTALatenessCharges)EmployeeSaveModel.TALatenessCharges) == Model.Employee.eTALatenessCharges.Applicable)
                    {
                        LatenessDays = dsAttendance.Count(r => r.LateIn && !r.LatenessApproved);
                    }

                    LoanInstallmentAmt = DALObj.GetLoanInstallmentAmt(EmployeeSaveModel.EmployeeID, DateFrom, DateTo);
                    #endregion
                }
                #endregion
            }
            CalculatePAYE();
            CalculatePayslipTab();
        }
コード例 #3
0
ファイル: frmEmployeePayslip.cs プロジェクト: ewin66/RAPH
        void ClearPayrollValues()
        {
            EmployeeSaveModel     = null;
            ServiceSaveModel      = null;
            EditingEmployeeDetail = null;
            NormalOvertimeHours   = 0;
            DoubleOvertimeHours   = 0;
            AbsentDays            = 0;
            NoticePayDay          = 0;
            LeaveEncashmentDays   = 0;
            WeekendWorkedDays     = 0;

            LatenessDays = 0;
            //LatenessAmt = 0;
            LoanInstallmentAmt = 0;

            lookUpVehicle_NonCashBenefit.EditValue = null;

            dsEarningAndDeduction.ForEach(r => r.Value = 0);
            gvEarnings.RefreshData();
            gvDeductions.RefreshData();

            dsNonCashBenefit.ForEach(r =>
            {
                r.Selected   = false;
                r.Recurrning = false;

                var defaultValues = dsNonCashBenefitDefaultValues.FirstOrDefault(dr => dr.NonCashBenefitID == r.NonCashBenefitID);
                if (defaultValues != null)
                {
                    r.KRAValue           = defaultValues.KRAValue;
                    r.KRAValuePercentage = defaultValues.KRAValuePercentage;
                    r.CostValue          = defaultValues.CostValue;
                }
            });
            gvNonCashBenefit.RefreshData();

            dsPAYERelief.ForEach(r =>
            {
                if (r.Mandatory == Model.Settings.ePAYEReliefeMandatory.Yes)
                {
                    r.Selected      = true;
                    r.PAYEReliefAmt = r.MonthlyLimit;
                }
                else
                {
                    r.Selected = false;
                }
                //r.PAYEReliefAmt = 0;
            });
            gvPAYERelief.RefreshData();

            cmbNSSF.SelectedIndex           = 1;
            cmbNHIFApplicable.SelectedIndex = 1;

            BasicIncome        = 0;
            HRA                = 0;
            GrossTaxableIncome = 0;
            TaxableIncome      = 0;
            NetTaxableIncome   = 0;

            PAYETaxableEarningBindingSource.Clear();
            gvTaxableEarnings.RefreshData();

            PAYENoncashBenefitBindingSource.Clear();
            gvPAYE_NonCashBenefit.RefreshData();

            PAYEReliefeBindingSource.Clear();
            gvPAYE_PAYERelief.RefreshData();
        }
コード例 #4
0
ファイル: EmployeePaySlipDAL.cs プロジェクト: ewin66/RAPH
        public SavingResult SavePayroll(int Month, int Year, tblPayrollEmployeeDetail EmployeeDetailSaveModel, List <EmployeePayslip_EarningAndDeductionsViewModel> EarningDeductions, List <EmployeePayslip_NoncashBenefitViewModel> NonCashBenefits, List <EmployeePayslip_PAYEReliefeViewModel> PAYERelief)
        {
            SavingResult res = new SavingResult();

            using (dbVisionEntities db = new dbVisionEntities())
            {
                tblPayroll SaveModel = db.tblPayrolls.FirstOrDefault(r => r.Month == Month && r.Year == Year);
                if (SaveModel == null)
                {
                    SaveModel = new tblPayroll()
                    {
                        Month = Month,
                        Year  = Year,
                    };

                    SaveModel.rcdt        = DateTime.Now;
                    SaveModel.rcuid       = CommonProperties.LoginInfo.LoggedinUser.UserID;
                    SaveModel.CompanyID   = CommonProperties.LoginInfo.LoggedInCompany.CompanyID;
                    SaveModel.FinPeriodID = CommonProperties.LoginInfo.LoggedInFinPeriod.FinPeriodID;

                    db.tblPayrolls.Add(SaveModel);
                }
                //else
                //{
                //    SaveModel.redt = DateTime.Now;
                //    SaveModel.reuid = CommonProperties.LoginInfo.LoggedinUser.UserID;

                //    db.tblPayrolls.Attach(SaveModel);
                //    db.Entry(SaveModel).State = System.Data.Entity.EntityState.Modified;

                //    db.tblPayrollEmployeeDetails.RemoveRange(db.tblPayrollEmployeeDetails.Where(r => r.PayrollID == SaveModel.PayrollID));
                //    db.tblPayrollEmployeeEarningsDeductions.RemoveRange(db.tblPayrollEmployeeEarningsDeductions.Where(r => r.PayrollID == SaveModel.PayrollID));
                //    db.tblPayrollEmployeeNonCashBenefits.RemoveRange(db.tblPayrollEmployeeNonCashBenefits.Where(r => r.PayrollID == SaveModel.PayrollID));
                //}

                if (EmployeeDetailSaveModel.PayrollEmployeeDetailID == 0)
                {
                    EmployeeDetailSaveModel.tblPayroll = SaveModel;
                    db.tblPayrollEmployeeDetails.Add(EmployeeDetailSaveModel);
                }
                else
                {
                    db.tblPayrollEmployeeDetails.Attach(EmployeeDetailSaveModel);
                    db.Entry(EmployeeDetailSaveModel).State = System.Data.Entity.EntityState.Modified;

                    db.tblPayrollEmployeeEarningsDeductions.RemoveRange(db.tblPayrollEmployeeEarningsDeductions.Where(r => r.PayrollEmployeeDetailID == EmployeeDetailSaveModel.PayrollEmployeeDetailID));
                    db.tblPayrollEmployeeNonCashBenefits.RemoveRange(db.tblPayrollEmployeeNonCashBenefits.Where(r => r.PayrollEmployeeDetailID == EmployeeDetailSaveModel.PayrollEmployeeDetailID));
                    db.tblPayrollEmployePAYEReliefs.RemoveRange(db.tblPayrollEmployePAYEReliefs.Where(r => r.PayrollEmployeeDetailID == EmployeeDetailSaveModel.PayrollEmployeeDetailID));
                }

                db.tblPayrollEmployeeEarningsDeductions.AddRange(EarningDeductions.Where(r => r.Value != 0).Select(r => new tblPayrollEmployeeEarningsDeduction()
                {
                    tblPayrollEmployeeDetail = EmployeeDetailSaveModel,
                    EarningsDeductionID      = r.EarningAndDeductionID,
                    Value     = r.Value,
                    Taxable   = r.Taxable,
                    ValueType = (byte)r.ValueType,
                }));

                db.tblPayrollEmployeeNonCashBenefits.AddRange(NonCashBenefits.Where(r => r.Selected).Select(r => new tblPayrollEmployeeNonCashBenefit()
                {
                    tblPayrollEmployeeDetail = EmployeeDetailSaveModel,
                    NonCashBenefitID         = r.NonCashBenefitID,
                    CostValue = r.CostValue,
                    KRAPerc   = r.KRAValuePercentage,
                    KRAValue  = r.KRAValue,
                    KRAValueCalculatedOnAmt = 0,
                    Recurring = r.Recurrning,
                }));


                db.tblPayrollEmployePAYEReliefs.AddRange(PAYERelief.Where(r => r.Selected && r.PAYEReliefAmt != 0).Select(r => new tblPayrollEmployePAYERelief()
                {
                    PayrollEmployeeDetailID = EmployeeDetailSaveModel.PayrollEmployeeDetailID,
                    PAYEReliefID            = r.PAYEReliefID,
                    PAYEReliefAmt           = r.PAYEReliefAmt,
                }));

                try
                {
                    db.SaveChanges();
                    res.ExecutionResult = eExecutionResult.CommitedSucessfuly;
                }
                catch (Exception ex)
                {
                    CommonFunctions.GetFinalError(res, ex);
                }

                return(res);
            }
        }