IMEX.mes.wcf/DK.Client/HRModule/F_HR_1202.cs

/*******************************************************************************
* Copyright(c) 2014 DongkeSoft All rights reserved. / Confidential
* 类的信息：
*      1.程序名称：F_HR_1202.cs
*      2.功能描述：工资结算记录查询
* 编辑履历：
*      作者            日期                版本            修改内容
*      庄天威          2014/09/12          1.00            新建
*******************************************************************************/

using System;
using System.Data;
using System.Windows.Forms;
using System.Text;
using Dongke.IBOSS.PRD.Basics.BaseControls;
using Dongke.IBOSS.PRD.Basics.BaseResources;
using Dongke.IBOSS.PRD.Basics.Library;
using Dongke.IBOSS.PRD.Client.CommonModule;
using Dongke.IBOSS.PRD.Client.DataModels;
using Dongke.IBOSS.PRD.WCF.Proxys;
using Dongke.IBOSS.PRD.WCF.Proxys.HRModuleService;
using Dongke.IBOSS.PRD.WCF.DataModels;

namespace Dongke.IBOSS.PRD.Client.HRModule
{
    public partial class F_HR_1202 : FormBase
    {
        #region 成员变量
        /// <summary>
        /// 主信息ID
        /// </summary>
        public int _mainId;
        /// <summary>
        /// 结算月
        /// </summary>
        public DateTime? _smouth; 
        /// <summary>
        /// 窗体模式
        /// </summary>
        public Constant.FormMode _formType; 
        /// <summary>
        /// 基础信息数据集
        /// </summary>
        public DataSet _dsBase; 
        /// <summary>
        /// 策略明细数据集
        /// </summary>
        public DataSet _dsStrategy; 
        /// <summary>
        /// 结算起始日
        /// </summary>
        public DateTime? _salaryDateS;  
        /// <summary>
        /// 结算终止日
        /// </summary>
        public DateTime? _salaryDateE; 
        /// <summary>
        /// 结算天数
        /// </summary>
        public int _mouthDay;
        /// <summary>
        /// 结算金额
        /// </summary>
        public decimal _salaryTotalMoney;
        /// <summary>
        /// 调整金额
        /// </summary>
        public decimal _adjustmentAmount;
        /// <summary>
        /// 顶端显示模式
        /// </summary>
        public int _topMode = 0;
        /// <summary>
        /// 当前页面是否结算
        /// </summary>
        public int _nowSettlement = 0;

        public DataTable _dtStaffSalary;
        public DataTable _dtBasicSalary;
        public DataTable _dtAttendance;
        public DataTable _dtWages;
        public DataTable _dtDefectFine;
        public DataTable _dtScrapFine;
        public DataTable _dtAdmin;
        public DataTable _dtAdminDetail;
        public DataTable _dtProgress;
        public DataTable _dtProgressDetail;
        public DataTable _dtManagerSalary;
        public DataTable _dtMain;

        #endregion

        #region 构造函数

        /// <summary>
        /// 构造函数
        /// </summary>
        public F_HR_1202(int mainId,Constant.FormMode formType)
        {
            InitializeComponent();
            _mainId = mainId;
            _formType = formType;
        }

        #endregion

        private void F_HR_1202_Load(object sender, EventArgs e)
        {
            try
            {
                CreateTable();
                BindPage();

                if(_formType == Constant.FormMode.Edit)
                {
                    this.tsbtnSettlement.Text = "结算or筛选(&J)";
                    //根据主ID获取全部明细信息
                    this.tsbtnSettlement.Enabled = false;
                    this.dtpStartTime.Enabled = false;

                    _nowSettlement = 1;
                    //已经通过审批的则不可以修改
                    foreach(DataGridViewRow gvrFor in this.dgvSettlement.Rows)
                    {
                        int AuditValue = Convert.ToInt32(gvrFor.Cells["AuditStatus"].Value);
                        if (AuditValue == 1)
                        {
                            gvrFor.Cells["AdjustmentAmount"].ReadOnly = true;
                            gvrFor.Cells["Remarks"].ReadOnly = true;
                        }
                    }
                }
                else if(_formType == Constant.FormMode.Display)
                {
                    this.tsbtnSettlement.Text = "结算or筛选(&J)";
                    //根据主ID获取全部明细信息
                    //控件除提交外全部不可用
                    //列表内复选框列可见
                    this.dgvSettlement.Columns["AuditStatus"].Visible = true;
                    this.dgvSettlement.Columns["AdjustmentAmount"].ReadOnly = true;
                    this.dgvSettlement.Columns["Remarks"].ReadOnly = true;
                    //已经被选中的要设置为只读
                    foreach(DataGridViewRow gvrFor in this.dgvSettlement.Rows)
                    {
                        int AuditValue = Convert.ToInt32(gvrFor.Cells["AuditStatus"].Value);
                        if(AuditValue == 1)
                        {
                            gvrFor.Cells["AuditStatus"].ReadOnly = true;
                        }
                    }

                    this.dtpStartTime.Enabled = false;
                    this.btnSettlement.Enabled = false;
                    this.txtRemarks.Enabled = false;

                    _nowSettlement = 1;
                }
                this.dgvSettlement.IsSetInputColumnsColor = true;
            }
            catch(Exception ex)
            {
                // 对异常进行共通处理
                ExceptionManager.HandleEventException(this.ToString(),
                    System.Reflection.MethodBase.GetCurrentMethod().Name, this.Text, ex);
            }
        }

        private void tsbtnSettlement_Click(object sender, EventArgs e)
        {
            try
            {
                if(_topMode == 0)
                {
                    if (_nowSettlement == 0)
                    {
                        MessageBox.Show("请先进行结算操作!",
                                this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
                        return;
                    }
                    _topMode = 1;
                    this.cgbSelect.Visible = true;
                    this.cgbBase.Visible = false;
                }
                else
                {
                    _topMode = 0;
                    this.cgbSelect.Visible = false;
                    this.cgbBase.Visible = true;
                }
            }
            catch(Exception ex)
            {
                // 对异常进行共通处理
                ExceptionManager.HandleEventException(this.ToString(),
                    System.Reflection.MethodBase.GetCurrentMethod().Name, this.Text, ex);
            }
        }

        private void tsbtnAdaptive_Click(object sender, EventArgs e)
        {
            this.dgvSettlement.AutoResizeColumns(DataGridViewAutoSizeColumnsMode.AllCells);
        }

        private void btnSubmit_Click(object sender, EventArgs e)
        {
            try
            {
                GetAdjustmentAmount();

                if (_formType == Constant.FormMode.Add)
                {
                    if (_nowSettlement == 0)
                    {
                        MessageBox.Show("当前页未成功进行结算，无法提交!",
                                this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
                        return;
                    }

                    //创建主信息实体
                    GetSalaryEntity gsEntity = new GetSalaryEntity();
                    gsEntity.AccountMonth = _smouth;
                    gsEntity.SalaryDateS = _salaryDateS;
                    gsEntity.SalaryDateE = _salaryDateE;
                    gsEntity.SettlementAmount = _salaryTotalMoney;
                    gsEntity.AdjustmentAmount = _adjustmentAmount;
                    gsEntity.TotalAmount = gsEntity.SettlementAmount + gsEntity.AdjustmentAmount;
                    gsEntity.Remarks = this.txtRemarks.Text;
                    //创建各明细信息数据集
                    DataSet dsStaffSalary = new DataSet();
                    dsStaffSalary.Tables.Add(_dtStaffSalary.Copy());
                    dsStaffSalary.Tables.Add(_dtBasicSalary.Copy());
                    dsStaffSalary.Tables.Add(_dtWages.Copy());
                    dsStaffSalary.Tables.Add(_dtDefectFine.Copy());
                    dsStaffSalary.Tables.Add(_dtScrapFine.Copy());
                    dsStaffSalary.Tables.Add(_dtAdmin.Copy());
                    dsStaffSalary.Tables.Add(_dtAdminDetail.Copy());
                    dsStaffSalary.Tables.Add(_dtProgress.Copy());
                    dsStaffSalary.Tables.Add(_dtProgressDetail.Copy());
                    dsStaffSalary.Tables.Add(_dtManagerSalary.Copy());

                    int SalaryReturn = HRModuleProxy.Service.AddSalarySettlement(gsEntity, dsStaffSalary, _dsBase);

                    if (SalaryReturn > 0)
                    {
                        // 提示信息
                        MessageBox.Show(string.Format(Messages.MSG_CMN_I001, "工资结算", "保存"),
                            this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
                    }
                    else
                    {
                        // 提示信息
                        MessageBox.Show(string.Format(Messages.MSG_CMN_W001, "工资结算", "保存"),
                            this.Text, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    }
                }
                else if(_formType == Constant.FormMode.Edit)
                {
                    GetSalaryEntity gsEntity = new GetSalaryEntity();
                    gsEntity.AdjustmentAmount = _adjustmentAmount;
                    gsEntity.TotalAmount = _salaryTotalMoney + _adjustmentAmount;
                    gsEntity.Remarks = this.txtRemarks.Text;
                    gsEntity.SalarySettlementID = _mainId;

                    int SalaryReturn = HRModuleProxy.Service.EditSalarySettlement(gsEntity, _dtStaffSalary);

                    if (SalaryReturn > 0)
                    {
                        // 提示信息
                        MessageBox.Show(string.Format(Messages.MSG_CMN_I001, "工资结算", "调整"),
                            this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
                    }
                    else
                    {
                        // 提示信息
                        MessageBox.Show(string.Format(Messages.MSG_CMN_W001, "工资结算", "调整"),
                            this.Text, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    }
                }
                else if(_formType == Constant.FormMode.Display)
                {
                    int SalaryReturn = HRModuleProxy.Service.AuditSalarySettlement(_dtStaffSalary);

                    if (SalaryReturn > 0)
                    {
                        // 提示信息
                        MessageBox.Show(string.Format(Messages.MSG_CMN_I001, "工资结算", "审批"),
                            this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
                    }
                    else
                    {
                        // 提示信息
                        MessageBox.Show(string.Format(Messages.MSG_CMN_W001, "工资结算", "审批"),
                            this.Text, MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    }
                }
            }
            catch (Exception ex)
            {
                // 对异常进行共通处理
                ExceptionManager.HandleEventException(this.ToString(),
                    System.Reflection.MethodBase.GetCurrentMethod().Name, this.Text, ex);
            }
        }

        private void btnClose_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        private void BindPage()
        {
            try
            {
                if (_formType == Constant.FormMode.Add)
                {
                    DataSet dsSMouth = SystemModuleProxy.Service.GetSettlementTime();
                    if (dsSMouth != null)
                    {
                        this.dtpStartTime.Enabled = false;
                        this.dtpStartTime.Value = Convert.ToDateTime(dsSMouth.Tables[0].Rows[0]["DateValue"]);
                        _smouth = Convert.ToDateTime(dsSMouth.Tables[0].Rows[0]["DateValue"]);
                    }
                    else
                    {
                        this.dtpStartTime.Enabled = true;
                    }
                }
                else if(_formType == Constant.FormMode.Edit || _formType == Constant.FormMode.Display)
                {
                    this.dgvSettlement.AutoGenerateColumns = false;
                    this.dgvSettlement.DataSource = _dtStaffSalary;

                    this.txtRemarks.Text = _dtMain.Rows[0]["Remarks"].ToString();
                    this.dtpStartTime.Value = Convert.ToDateTime(_dtMain.Rows[0]["AccountMonth"]);
                }
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }

        private void GetBaseData()
        {
            try
            {
                GetSalaryEntity gsEntity = new GetSalaryEntity();

                //首先获取结算日期
                int SDay = 0;
                DataTable dtSysData = SystemModuleProxy.Service.GetSystemData().Tables[0];
                foreach (DataRow drFor in dtSysData.Rows)
                {
                    if (drFor["SettingCode"].ToString().Trim() == "S_CMN_0003")
                    {
                        if (drFor["SettingValue"].ToString() == "月末")
                        {
							SDay = Convert.ToInt32(DateTime.DaysInMonth(this.dtpStartTime.Value.Year, this.dtpStartTime.Value.Month));
                        }
                    }
                }
                //然后获取结算月,如果有取那个月，如果没有界面获取的月
                DateTime dtSMouth;
                if (_smouth != null)
                {
                    dtSMouth = Convert.ToDateTime(_smouth).AddDays(-Convert.ToDateTime(_smouth).Day + 1);
                }
                else
                {
                    dtSMouth = this.dtpStartTime.Value.Date.AddDays(-this.dtpStartTime.Value.Date.Day + 1);
                    _smouth = dtSMouth;
                }

                //计算出结算起始日和终止日
                DateTime SalaryDateS = dtSMouth;
                DateTime SalaryDateE = dtSMouth.AddDays(SDay);

                gsEntity.SalaryDateS = SalaryDateS;
                gsEntity.SalaryDateE = SalaryDateE.AddHours(23).AddMinutes(59).AddSeconds(59).AddDays(-1);
                _salaryDateS = SalaryDateS;
                _salaryDateE = SalaryDateE;
                //因为要算上结算最后一天的本体，所以要+1
                _mouthDay = ((TimeSpan)(SalaryDateE - SalaryDateS)).Days;
                //获取全部策略明细信息
                DataSet dsStrategy = TATModuleProxy.Service.GetAllUseStrategy(SalaryDateS);
                _dsStrategy = dsStrategy;
                if (_dsStrategy.Tables[2].Rows.Count != 0 && _dsStrategy.Tables[3].Rows.Count != 0)
                {
                    gsEntity.WagesMainId = Convert.ToInt32(_dsStrategy.Tables[2].Rows[0]["WagesId"]);
                    gsEntity.WagesMainIdE = Convert.ToInt32(_dsStrategy.Tables[3].Rows[0]["WagesId"]);
                }
                else
                {
                    //没有对应的工价明细
                    return;
                }
                //最后获取全部基础信息
                DataSet dsBase = HRModuleProxy.Service.GetSalaryData(gsEntity);
                _dsBase = dsBase;

                //进行结算
                Settlement();
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }

        private void Settlement()
        {
            int row = 0;
            try
            {
                //获取全部员工并遍历
                DataTable dtStaff = _dsBase.Tables[6];
                
                foreach (DataRow drStaff in dtStaff.Rows)
                {
                    //if (row > 10)
                    //{
                    //    break;
                    //}
                    row++;
                    //if(row==1564)
                    //{
                    //    int a = 0;
                    //}
                    //员工ID
                    int StaffId = Convert.ToInt32(drStaff["StaffId"]);
                    //员工工种
                    int StaffJobsId = Convert.ToInt32(drStaff["Jobs"]);
                    //员工状态
                    int StaffStatus = Convert.ToInt32(drStaff["StaffStatus"]);
                    //员工入职时间
                    if (drStaff["EntryDate"] != DBNull.Value)
                    {
                        DateTime StaffEntryDate = Convert.ToDateTime(drStaff["EntryDate"]);
                    }
                    //员工离职时间
                    DateTime? StaffTurnoverDate = null;
                    if (drStaff["TurnoverDate"] != DBNull.Value)
                    {
                        StaffTurnoverDate = Convert.ToDateTime(drStaff["TurnoverDate"]);
                    }

                    #region 基本工资 + 行政奖惩 + 进度奖惩
                    //该员工基本工资（基本工资+出勤考核）
                    decimal BSalary = 0;
                    //该员工行政考核总额
                    decimal ASalary = 0;
                    //该员工进度考核总额
                    decimal PSalary = 0;
                    //基本工资部分，首先查看该人员是否有人事变动
                    DataTable dtRecord = _dsBase.Tables[7].Copy();
                    dtRecord.DefaultView.RowFilter = " StaffId = " + StaffId;
                    DataTable dtRecordNow = dtRecord.DefaultView.ToTable();
                    //如果有人事变动的话
                    if (dtRecordNow.Rows.Count != 0)
                    {
                        //遍历人事变动，从结算开始日起，到第一条记录的审批日期，为该员工担当该履历调整前工种
                        //后面的以此类推,第一条记录的审批日期至第二条记录的审批日期，为该员工担当第二条履历的调整前工种
                        //当然，存储过程获取的是结算时间段内审批通过的信息,所以无需担心审批日大于结算终止日
                        //结算每一条履历完毕后要把已结算日期(RecordStartTime)保存起来，履历遍历结束后如果记录时间小于结算终止日，还要计算员工当前工种的工资
                        //计算当前工种工资为最后一条履历的审批时间至结算终止日
                        DateTime RecordStartTime = Convert.ToDateTime(_salaryDateS);
                        int LastTargetJobs = 0;
                        int LastStatus = 0;
                        foreach (DataRow drRecordFor in dtRecordNow.Rows)
                        {
                            //首先查看该履历中的变动前状态，如果是未入职/离职的话，直接下一条信息
                            if (Convert.ToInt32(drRecordFor["OriginalStaffStatus"]) == 0
                                || Convert.ToInt32(drRecordFor["OriginalStaffStatus"]) == 3)
                            {
                                RecordStartTime = Convert.ToDateTime(drRecordFor["ApprovalDate"]);
                                LastStatus = Convert.ToInt32(drRecordFor["TargetStaffStatus"]);
                                LastTargetJobs = Convert.ToInt32(drRecordFor["TargetJobs"]);
                                continue;
                            }

                            //其次获取该履历中的变动前工种，即该员工从开始结算日-审批日中间的工种
                            int RFJobsId = Convert.ToInt32(drRecordFor["OriginalJobs"]);
                            //获取变动前状态，分辨是试用还是正式
                            int RFStatus = Convert.ToInt32(drRecordFor["OriginalStaffStatus"]);
                            //获取审批通过时间(即变化工种时间)
                            DateTime UpdateTime = Convert.ToDateTime(drRecordFor["ApprovalDate"]);
                            //计算该工种担当时间的工资，累加(-1天是因为审核当天就变成另一个工种了，那一天是下次结算的)
                            BSalary += this.GetBSalaryByJobsId(StaffId, RFJobsId, RFStatus, RecordStartTime, UpdateTime);
                            //并同时计算该时间段的行政奖惩金额
                            ASalary += this.GetASalaryByJobsId(StaffId, RFJobsId, RFStatus, RecordStartTime, UpdateTime);
                            //并同时计算该时间段的进度奖惩金额
                            PSalary += this.GetPSalaryByJobsId(StaffId, RFJobsId, RFStatus, RecordStartTime, UpdateTime);

                            //更新已结算日期，循环
                            RecordStartTime = UpdateTime;
                            LastStatus = Convert.ToInt32(drRecordFor["TargetStaffStatus"]);
                            if (LastStatus == 0 || LastStatus == 3)//同上,保护后面的值不会取空
                            {
                                continue;
                            }
                            LastTargetJobs = Convert.ToInt32(drRecordFor["TargetJobs"]);
                        }
                        //如果循环完毕后，如果已结算日期不等于结算终止日
                        //那么要算出已结算日期-结算终止日的循环完毕后遗留的“变动后工种”的工资
                        //步骤同上
                        if (LastStatus != 0 && LastStatus != 3)
                        {
                            BSalary += this.GetBSalaryByJobsId(StaffId, LastTargetJobs, LastStatus, RecordStartTime, Convert.ToDateTime(_salaryDateE));
                            ASalary += this.GetASalaryByJobsId(StaffId, LastTargetJobs, LastStatus, RecordStartTime, Convert.ToDateTime(_salaryDateE));
                            PSalary += this.GetPSalaryByJobsId(StaffId, LastTargetJobs, LastStatus, RecordStartTime, Convert.ToDateTime(_salaryDateE));
                        }
                    }
                    else
                    {
                        //当段时间内没有人事变动的话，要获取结算日期前的最后一次履历，进行相关逻辑结算
                        DataTable dtUpRecord = _dsBase.Tables[8];
                        dtUpRecord.DefaultView.RowFilter = " StaffId = " + StaffId;
                        DataTable dtUpRecordNow = dtRecord.DefaultView.ToTable();

                        if (dtUpRecordNow.Rows.Count != 0)
                        {
                            DataRow drUpRecord = dtUpRecord.Rows[0];
                            BSalary += this.GetBSalaryByJobsId(StaffId, Convert.ToInt32(drUpRecord["TargetJobs"]),
                                Convert.ToInt32(drUpRecord["TargetStaffStatus"]), Convert.ToDateTime(_salaryDateS),
                                Convert.ToDateTime(_salaryDateE));
                            ASalary += this.GetASalaryByJobsId(StaffId, Convert.ToInt32(drUpRecord["TargetJobs"]),
                                Convert.ToInt32(drUpRecord["TargetStaffStatus"]), Convert.ToDateTime(_salaryDateS),
                                Convert.ToDateTime(_salaryDateE));
                            PSalary += this.GetPSalaryByJobsId(StaffId, Convert.ToInt32(drUpRecord["TargetJobs"]),
                                Convert.ToInt32(drUpRecord["TargetStaffStatus"]), Convert.ToDateTime(_salaryDateS),
                                Convert.ToDateTime(_salaryDateE));
                        }
                        else //直接取员工本身的
                        {
                            BSalary += this.GetBSalaryByJobsId(StaffId, StaffJobsId, StaffStatus,
                                Convert.ToDateTime(_salaryDateS), Convert.ToDateTime(_salaryDateE));
                            ASalary += this.GetASalaryByJobsId(StaffId, StaffJobsId, StaffStatus,
                                Convert.ToDateTime(_salaryDateS), Convert.ToDateTime(_salaryDateE));
                            PSalary += this.GetPSalaryByJobsId(StaffId, StaffJobsId, StaffStatus,
                                Convert.ToDateTime(_salaryDateS), Convert.ToDateTime(_salaryDateE));
                        }
                    }
                    #endregion

                    #region 计件工资
                    //该员工计件工资
                    decimal CSalary = 0;
                    //获取该员工参与的全部生产数据（计条码，计件，计窑车）
                    DataTable dtBarCode = _dsBase.Tables[9].Copy();
                    dtBarCode.DefaultView.RowFilter = " StaffId = " + StaffId;
                    DataTable dtBarCodeNow = dtBarCode.DefaultView.ToTable();
                    foreach (DataRow drNowFor in dtBarCodeNow.Rows)
                    {
                        //计条码的，直接累加对应商品的工价*计价单位数量即可
                        if (drNowFor["PieceNum"] != DBNull.Value || drNowFor["Wages"] != DBNull.Value)
                        {
                            CSalary += Convert.ToDecimal(drNowFor["PieceNum"]) * Convert.ToDecimal(drNowFor["Wages"]);
                        }
                        //添加计件工资明细
                        DataRow drWages = _dtWages.NewRow();
                        drWages["WagesJobs"] = drNowFor["UJobsID"];
                        drWages["StaffID"] = StaffId;
                        drWages["SalaryType"] = drNowFor["StaffStatus"];
                        drWages["PriceType"] = drNowFor["PriceType"];
                        drWages["AccountDateFrom"] = _salaryDateS;
                        drWages["AccountDateTo"] = _salaryDateE;
                        drWages["BarCode"] = drNowFor["BarCode"];
                        drWages["GoodsId"] = drNowFor["GoodsId"];
                        drWages["GoodsLevelTypeID"] = drNowFor["GoodsLevelTypeID"];
                        drWages["Wages"] = drNowFor["Wages"];
                        drWages["Salary"] = Convert.ToDecimal(drNowFor["PieceNum"]) * Convert.ToDecimal(drNowFor["Wages"]);
                        _dtWages.Rows.Add(drWages);
                    }

                    DataTable dtCount = _dsBase.Tables[0].Copy();
                    dtCount.DefaultView.RowFilter = " StaffId = " + StaffId;
                    DataTable dtCountNow = dtCount.DefaultView.ToTable();
                    foreach (DataRow drNowFor in dtCountNow.Rows)
                    {
                        //计件同理，直接累加对应商品的工价*计价单位数量即可
                        if (drNowFor["PieceNum"] != DBNull.Value || drNowFor["Wages"] != DBNull.Value)
                        {
                            CSalary += Convert.ToDecimal(drNowFor["PieceNum"]) * Convert.ToDecimal(drNowFor["Wages"]);
                        }
                        //添加计件工资明细
                        DataRow drWages = _dtWages.NewRow();
                        drWages["WagesJobs"] = drNowFor["UJobsID"];
                        drWages["StaffID"] = StaffId;
                        drWages["SalaryType"] = drNowFor["StaffStatus"];
                        drWages["PriceType"] = drNowFor["PriceType"];
                        drWages["AccountDateFrom"] = _salaryDateS;
                        drWages["AccountDateTo"] = _salaryDateE;
                        drWages["BarCode"] = drNowFor["BarCode"];
                        drWages["GoodsId"] = drNowFor["GoodsId"];
                        drWages["GoodsLevelTypeID"] = drNowFor["GoodsLevelTypeID"];
                        drWages["Wages"] = drNowFor["Wages"];
                        drWages["Salary"] = Convert.ToDecimal(drNowFor["PieceNum"]) * Convert.ToDecimal(drNowFor["Wages"]);
                        _dtWages.Rows.Add(drWages);
                    }

                    DataTable dtCar = _dsBase.Tables[5].Copy();
                    dtCar.DefaultView.RowFilter = " StaffId = " + StaffId;
                    DataTable dtCarNow = dtCar.DefaultView.ToTable();
                    foreach (DataRow drNowFor in dtCarNow.Rows)
                    {
                        //计车的，累加每车单价以及计车单位数
                        CSalary += Convert.ToDecimal(drNowFor["KilnCarNum"]) * Convert.ToDecimal(drNowFor["CarPricing"]);
                        //添加计件工资明细
                        DataRow drWages = _dtWages.NewRow();
                        drWages["WagesJobs"] = drNowFor["UJobsID"];
                        drWages["StaffID"] = StaffId;
                        drWages["SalaryType"] = drNowFor["StaffStatus"];
                        drWages["PriceType"] = drNowFor["PriceType"];
                        drWages["AccountDateFrom"] = _salaryDateS;
                        drWages["AccountDateTo"] = _salaryDateE;
                        drWages["KilnID"] = drNowFor["KilnID"];
                        drWages["KilnCarID"] = drNowFor["KilnCarID"];
                        drWages["IntoKilnTime"] = drNowFor["IntoKilnTime"];
                        drWages["OutKilnTime"] = drNowFor["OutKilnTime"];
                        drWages["Wages"] = drNowFor["CarPricing"];
                        drWages["Salary"] = Convert.ToDecimal(drNowFor["KilnCarNum"]) * Convert.ToDecimal(drNowFor["CarPricing"]);
                        _dtWages.Rows.Add(drWages);
                    }

                    DataTable dtWeight = _dsBase.Tables[11].Copy();
                    dtWeight.DefaultView.RowFilter = " StaffId = " + StaffId;
                    DataTable dtWeightNow = dtWeight.DefaultView.ToTable();
                    foreach(DataRow drNowFor in dtWeightNow.Rows)
                    {
                        //计重量的，用重量乘单价乘单位数
                        CSalary += Convert.ToDecimal(drNowFor["Lusterwareweight"]) * Convert.ToDecimal(drNowFor["WeightPricing"])
                            * Convert.ToDecimal(drNowFor["Weight"]);
                        //添加计件工资明细
                        DataRow drWages = _dtWages.NewRow();
                        drWages["WagesJobs"] = drNowFor["UJobsID"];
                        drWages["StaffID"] = StaffId;
                        drWages["SalaryType"] = drNowFor["StaffStatus"];
                        drWages["PriceType"] = drNowFor["PriceType"];
                        drWages["AccountDateFrom"] = _salaryDateS;
                        drWages["AccountDateTo"] = _salaryDateE;
                        drWages["Wages"] = drNowFor["WeightPricing"];
                        drWages["Salary"] = Convert.ToDecimal(drNowFor["Lusterwareweight"]) * Convert.ToDecimal(drNowFor["WeightPricing"])
                            * Convert.ToDecimal(drNowFor["Weight"]);
                        _dtWages.Rows.Add(drWages);
                    }


                    #endregion

                    #region 缺陷扣罚
                    //该员工缺陷扣罚总额
                    decimal DSalary = 0;
                    //获取该员工相关的缺陷扣罚信息
                    DataTable dtDefect = _dsBase.Tables[3].Copy();
                    dtDefect.DefaultView.RowFilter = " StaffId = " + StaffId;
                    DataTable dtDefectNow = dtDefect.DefaultView.ToTable();
                    //获取全部缺陷扣罚明细
                    DataTable dtDefectDetail = _dsStrategy.Tables[4].Copy();

                    foreach (DataRow drFor in dtDefectNow.Rows)
                    {
                        //首先根据缺陷扣罚类别,获取明细
                        dtDefectDetail.DefaultView.RowFilter = " DefectFine = " + drFor["DefectFine"].ToString()
                            + " and SalaryType = " + (Convert.ToInt32(drFor["StaffStatus"]) - 1);
                        DataTable dtDefectDetailNow = dtDefectDetail.DefaultView.ToTable();
                        if (dtDefectDetailNow.Rows.Count != 0)
                        {
                            //那么首先获取第一行,如果是按金额扣罚,直接获取金额即可
                            //如果是按工价比例扣罚,那么还要进一步根据产品来匹配工价以及策略扣罚比例
                            DataRow drDetailTop = dtDefectDetailNow.Rows[0];

                            DataRow drDefect = _dtDefectFine.NewRow();
                            drDefect["StaffID"] = StaffId;
                            drDefect["StaffStatus"] = drFor["StaffStatus"];
                            drDefect["JobsID"] = drFor["UJobsID"];
                            drDefect["SalaryType"] = (Convert.ToInt32(drFor["StaffStatus"]) - 1);
                            drDefect["BeginDate"] = _salaryDateS; ;
                            drDefect["EndDate"] = _salaryDateE;
                            drDefect["BarCode"] = drFor["BarCode"];
                            drDefect["DefectFine"] = drFor["DefectFine"];
                            drDefect["FineType"] = drDetailTop["FineType"];

                            if (Convert.ToInt32(drDetailTop["FineType"]) == 2)
                            {
                                //筛选条件包含工种,状态,产品
                                dtDefectDetailNow.DefaultView.RowFilter = " JobsID = " + drFor["UJobsID"] + " and GoodsID = " + drFor["GoodsID"]
                                    + " and SalaryType = " + (Convert.ToInt32(drFor["StaffStatus"]) - 1);
                                DataTable dtDefectGoods = dtDefectDetailNow.DefaultView.ToTable();
                                if (dtDefectGoods.Rows.Count != 0)
                                {
                                    DSalary += Convert.ToDecimal(dtDefectGoods.Rows[0]["FineAmount"]);
                                    drDefect["FineAmount"] = Convert.ToDecimal(dtDefectGoods.Rows[0]["FineAmount"]);
                                }
                            }
                            else
                            {
                                //借用结算计件工资时的两个数据集,因为这时候不清楚缺陷扣罚的那个生产数据是根据什么计的,所以要分别在两个数据集中找
                                //找到了之后,用工价乘以缺陷扣罚中的百分比即可
                                dtBarCodeNow.DefaultView.RowFilter = " BarCode = " + drFor["BarCode"] + " and UJobsID = " + drFor["UJobsID"]
                                    + " and StaffStatus = " + drFor["StaffStatus"];
                                DataTable dtWagesByBarCode = dtBarCodeNow.DefaultView.ToTable();
                                dtCountNow.DefaultView.RowFilter = " BarCode = " + drFor["BarCode"] + " and UJobsID = " + drFor["UJobsID"]
                                    + " and StaffStatus = " + drFor["StaffStatus"];
                                DataTable dtWagesByCount = dtCountNow.DefaultView.ToTable();
                                if (dtWagesByBarCode.Rows.Count != 0)
                                {
                                    DSalary += Convert.ToDecimal(dtWagesByBarCode.Rows[0]["Wages"]) * Convert.ToDecimal(drDetailTop["Coefficient"]) / 100;
                                    drDefect["FineAmount"] = Convert.ToDecimal(dtWagesByBarCode.Rows[0]["Wages"]) * Convert.ToDecimal(drDetailTop["Coefficient"]) / 100;
                                }
                                else if (dtWagesByCount.Rows.Count != 0)
                                {
                                    DSalary += Convert.ToDecimal(dtWagesByCount.Rows[0]["Wages"]) * Convert.ToDecimal(drDetailTop["Coefficient"]) / 100;
                                    drDefect["FineAmount"] = Convert.ToDecimal(dtWagesByCount.Rows[0]["Wages"]) * Convert.ToDecimal(drDetailTop["Coefficient"]) / 100;
                                }
                                else
                                {
                                    drDefect["FineAmount"] = 0;
                                }
                            }
                            _dtDefectFine.Rows.Add(drDefect);
                        }
                        else
                        {
                            continue;
                        }
                    }
                    #endregion

                    #region 损坯扣罚
                    //损坯扣罚金额
                    decimal SSalary = 0;
                    //获取该员工相关的缺陷扣罚信息
                    DataTable dtScrapProduct = _dsBase.Tables[10].Copy();
                    dtScrapProduct.DefaultView.RowFilter = " StaffId = " + StaffId;
                    DataTable dtScrapProductNow = dtScrapProduct.DefaultView.ToTable();
                    foreach (DataRow drFor in dtScrapProductNow.Rows)
                    {
                        SSalary += Convert.ToDecimal(drFor["ScrapFine"]);
                        DataRow drScrapFine = _dtScrapFine.NewRow();
                        drScrapFine["StaffID"] = StaffId;
                        drScrapFine["StaffStatus"] = drFor["StaffStatus"];
                        drScrapFine["JobsID"] = drFor["UJobsID"];
                        drScrapFine["BeginDate"] = _salaryDateS;
                        drScrapFine["EndDate"] = _salaryDateE;
                        drScrapFine["BarCode"] = drFor["BarCode"];
                        drScrapFine["GoodsID"] = drFor["GoodsID"];
                        drScrapFine["ScrapTime"] = drFor["ScrapDate"];
                        drScrapFine["ScrapFine"] = drFor["ScrapFine"];
                        _dtScrapFine.Rows.Add(drScrapFine);
                    }
                    #endregion

                    #region 工资总计
                    DataRow drStaffSalary = _dtStaffSalary.NewRow();
                    drStaffSalary["StaffID"] = StaffId;
                    drStaffSalary["StaffName"] = drStaff["StaffName"];
                    drStaffSalary["OrganizationName"] = drStaff["OrganizationName"];
                    drStaffSalary["PostName"] = drStaff["PostName"];
                    drStaffSalary["AccountMonth"] = _smouth;
                    drStaffSalary["AccountDateFrom"] = _salaryDateS;
                    drStaffSalary["AccountDateTo"] = _salaryDateE;
                    drStaffSalary["BasicSalary"] = BSalary;
                    drStaffSalary["WagesSalary"] = CSalary;
                    drStaffSalary["DefectFine"] = DSalary;
                    drStaffSalary["ScrapFine"] = SSalary;
                    drStaffSalary["AdminSalary"] = ASalary;
                    drStaffSalary["ProgressSalary"] = PSalary;
                    drStaffSalary["AuditStatus"] = 0;
                    drStaffSalary["TotalAmount"] = BSalary + CSalary - DSalary - SSalary + ASalary + PSalary;
                    drStaffSalary["SettlementAmount"] = BSalary + CSalary - DSalary - SSalary + ASalary + PSalary;
                    drStaffSalary["AdjustmentAmount"] = 0;
                    _dtStaffSalary.Rows.Add(drStaffSalary);
                    #endregion

                    _salaryTotalMoney += BSalary + CSalary - DSalary - SSalary + ASalary + PSalary;
                }

                #region 管理者工资
                //全部结算完毕后，重新循环一次页面列表数据源
                foreach(DataRow drFor in _dtStaffSalary.Rows)
                {
                    decimal MSalary = 0;
                    //过程就是，获取每一个已结算的员工，查询该员工在管理者策略中是否担当管理者
                    //如果是，那么查询该管理者所属的所有组员，获取他们的已结算工资，并根据管理者策略明细计算出该管理者的工资
                    //如果否，进入下一个员工的循环
                    int StaffId = Convert.ToInt32(drFor["StaffID"]);
                    DataTable dtManagersDetail = _dsStrategy.Tables[7];
                    dtManagersDetail.DefaultView.RowFilter = " Manager = " + StaffId;
                    DataTable dtManagerToMember = dtManagersDetail.DefaultView.ToTable();

                    //如果筛选后依然存在信息，那么该员工就是管理者
                    if(dtManagerToMember.Rows.Count != 0)
                    {
                        //首先获取第一行，查看该管理者工资的计算方式
                        int SalaryType = Convert.ToInt32(dtManagerToMember.Rows[0]["SalaryType"]);
                        int MemberId = Convert.ToInt32(dtManagerToMember.Rows[0]["ManagersID"]);
                        int ManagerSalaryID = Convert.ToInt32(dtManagerToMember.Rows[0]["ManagerSalaryID"]);
                        if(SalaryType == 1)  //平均工资的话，遍历所有组员，找到对应结算信息，累加工资，并算出平均数
                        {
                            int MemberCount = 0;
                            decimal MemberTotalSalary = 0;
                            foreach(DataRow drMemberFor in dtManagerToMember.Rows)
                            {
                                _dtStaffSalary.DefaultView.RowFilter = " StaffId = " + drMemberFor["Member"];
                                DataTable dtMemberSalary = _dtStaffSalary.DefaultView.ToTable();
                                if(dtMemberSalary.Rows.Count != 0)
                                {
                                    MemberTotalSalary += Convert.ToDecimal(dtMemberSalary.Rows[0]["SettlementAmount"]);
                                    MemberCount++;
                                }
                            }
                            MSalary = MemberTotalSalary / MemberCount;
                        }
                        else if (SalaryType == 2)  //最高工资的话，遍历所有组员，获取最高的金额
                        {
                            decimal MemberMaxSalary = 0;
                            foreach (DataRow drMemberFor in dtManagerToMember.Rows)
                            {
                                _dtStaffSalary.DefaultView.RowFilter = " StaffId = " + drMemberFor["Member"];
                                DataTable dtMemberSalary = _dtStaffSalary.DefaultView.ToTable();
                                if (dtMemberSalary.Rows.Count != 0)
                                {
                                    decimal MemberSalaryFor = Convert.ToDecimal(dtMemberSalary.Rows[0]["SettlementAmount"]);
                                    if(MemberMaxSalary < MemberSalaryFor)
                                    {
                                        MemberMaxSalary = MemberSalaryFor;
                                    }
                                }
                            }
                            MSalary = MemberMaxSalary;
                        }
                        else if(SalaryType == 3)
                        {
                            decimal MemberMinSalary = 0;
                            foreach (DataRow drMemberFor in dtManagerToMember.Rows)
                            {
                                _dtStaffSalary.DefaultView.RowFilter = " StaffId = " + drMemberFor["Member"];
                                DataTable dtMemberSalary = _dtStaffSalary.DefaultView.ToTable();
                                if (dtMemberSalary.Rows.Count != 0)
                                {
                                    decimal MemberSalaryFor = Convert.ToDecimal(dtMemberSalary.Rows[0]["SettlementAmount"]);
                                    if (MemberMinSalary > MemberSalaryFor)
                                    {
                                        MemberMinSalary = MemberSalaryFor;
                                    }
                                }
                            }
                            MSalary = MemberMinSalary;
                        }
                        //保存管理者工资明细
                        DataRow drManagerSalary = _dtManagerSalary.NewRow();
                        drManagerSalary["StaffID"] = StaffId;
                        drManagerSalary["Member"] = MemberId;
                        drManagerSalary["Salary"] = MSalary;
                        _dtManagerSalary.Rows.Add(drManagerSalary);
                        //并修改界面数据源的值
                        drFor["ManagerSalary"] = MSalary;
                        drFor["TATManagersID"] = ManagerSalaryID;
                        drFor["TotalAmount"] = Convert.ToDecimal(drFor["TotalAmount"]) + MSalary;
                        drFor["SettlementAmount"] = Convert.ToDecimal(drFor["SettlementAmount"]) + MSalary;
                        _salaryTotalMoney += MSalary;
                    }
                    else
                    {
                        drFor["ManagerSalary"] = 0;
                        continue;
                    }
                }
                #endregion

                //清空筛选条件
                _dtStaffSalary.DefaultView.RowFilter = "";
                this.dgvSettlement.AutoGenerateColumns = false;
                this.dgvSettlement.DataSource = _dtStaffSalary;
                this.dgvSettlement.IsSetInputColumnsColor = true;
                _nowSettlement = 1;
            }
            catch(Exception ex)
            {
                int errorrow = row;
                throw ex;
            }
        }

        ///<summary> 
        /// 统计一段时间内有多少个星期几 
        ///</summary> 
        ///<param   name= "TimeStart"> 开始日期 </param> 
        ///<param   name= "TimeEnd"> 结束日期 </param> 
        ///<param   name= "AWeek "> 星期几 </param> 
        ///<returns> 返回个数 </returns> 
        public int TotalWeeks(DateTime TimeStart, DateTime TimeEnd, DayOfWeek AWeek)
        {
            TimeSpan vTimeSpan = new TimeSpan(TimeEnd.Ticks - TimeStart.Ticks);
            int Result = (int)vTimeSpan.TotalDays / 7;
            for (int i = 0; i <= vTimeSpan.TotalDays % 7; i++)
                if (TimeStart.AddDays(i).DayOfWeek == AWeek)
                    return Result + 1;
            return Result;
        }  

        /// <summary>
        /// 计算基本工资
        /// </summary>
        /// <param name="StaffId">员工ID</param>
        /// <param name="JobsId">工种ID</param>
        /// <param name="JobsStatus">状态（正式或实习）</param>
        /// <param name="StartTime">开始时间</param>
        /// <param name="EndTime">结束时间</param>
        /// <returns></returns>
        public decimal GetBSalaryByJobsId(int StaffId,int JobsId,int JobsStatus,DateTime StartTime,DateTime EndTime)
        {
            try
            {
                decimal BisicSalary = 0;

                //变动前工种持续时间(天数)
                int JobsDay = ((TimeSpan)(EndTime - StartTime)).Days;
                //查询该工种的基本工资策略明细,以获取基本工资(月)以及补贴
                decimal BasicSalaryMouth = 0;  //基本工资(月)
                decimal Subsidy = 0;  //补贴
                DataTable dtBasic = _dsStrategy.Tables[0].Copy();
                dtBasic.DefaultView.RowFilter = "salarytype = " + (JobsStatus - 1) + " and JobsID = " + JobsId;//筛选条件为工种+状态
                DataTable dtBasicNow = dtBasic.DefaultView.ToTable();
                if (dtBasicNow.Rows.Count == 0)
                {
                    //没有对应工资策略,返回
                    return 0;
                }
                else
                {
                    BasicSalaryMouth = Convert.ToDecimal(dtBasicNow.Rows[0]["BasicSalary"]);
                    Subsidy = Convert.ToDecimal(dtBasicNow.Rows[0]["Subsidy"]);
                }
                //然后要获取该工种的出勤策略明细，以计算该工种的日工资和每月可休息天数
                decimal daySalrty = 0; //日工资
                int restDaysMouth = 0; //每月可休息天数
                int restDaysNow = 0; //担当该工种时间内可休息天数
                int PunishMode = 0; //扣罚方式 1：比例 2：阶梯
                int RestmMode = 0; //休息方式 1:星期某 2:天数
                DataTable dtAttendance = _dsStrategy.Tables[1].Copy();
                dtAttendance.DefaultView.RowFilter = " JobsId = " + JobsId;
                DataTable dtAttendanceNow = dtAttendance.DefaultView.ToTable();
                //查看该策略明细的休息方式
                //如果取出多条，是因为阶梯扣罚的关系，取第一条即可
                if (dtAttendanceNow.Rows.Count != 0)
                {
                    DataRow drAttendanceNow = dtAttendanceNow.Rows[0];
                    PunishMode = Convert.ToInt32(drAttendanceNow["PunishMode"]);
                    RestmMode = Convert.ToInt32(drAttendanceNow["RestmMode"]);
                    if (Convert.ToInt32(drAttendanceNow["RestmMode"]) == 1) //如果是按照星期某休
                    {
                        //遍历7个星期字段，如果星期某是休息，那么算出该段时间内有几个星期某，累加在休息天数上
                        //-1是因为要算改变前的那一天。
                        //同时算出该月可休多少天，以及担当该工种时间内可休多少天
                        if (Convert.ToInt32(drAttendanceNow["Monday"]) == 0)
                        {
                            restDaysMouth += TotalWeeks(Convert.ToDateTime(_salaryDateS),
                                Convert.ToDateTime(_salaryDateE).AddDays(-1), DayOfWeek.Monday);
                            restDaysNow += TotalWeeks(StartTime, EndTime.AddDays(-1), DayOfWeek.Monday);
                        }
                        if (Convert.ToInt32(drAttendanceNow["Tuesday"]) == 0)
                        {
                            restDaysMouth += TotalWeeks(Convert.ToDateTime(_salaryDateS),
                                Convert.ToDateTime(_salaryDateE).AddDays(-1), DayOfWeek.Tuesday);
                            restDaysNow += TotalWeeks(StartTime, EndTime.AddDays(-1), DayOfWeek.Tuesday);
                        }
                        if (Convert.ToInt32(drAttendanceNow["Wednesday"]) == 0)
                        {
                            restDaysMouth += TotalWeeks(Convert.ToDateTime(_salaryDateS),
                                Convert.ToDateTime(_salaryDateE).AddDays(-1), DayOfWeek.Wednesday);
                            restDaysNow += TotalWeeks(StartTime, EndTime.AddDays(-1), DayOfWeek.Wednesday);
                        }
                        if (Convert.ToInt32(drAttendanceNow["Thursday"]) == 0)
                        {
                            restDaysMouth += TotalWeeks(Convert.ToDateTime(_salaryDateS),
                                Convert.ToDateTime(_salaryDateE).AddDays(-1), DayOfWeek.Thursday);
                            restDaysNow += TotalWeeks(StartTime, EndTime.AddDays(-1), DayOfWeek.Thursday);
                        }
                        if (Convert.ToInt32(drAttendanceNow["Friday"]) == 0)
                        {
                            restDaysMouth += TotalWeeks(Convert.ToDateTime(_salaryDateS),
                                Convert.ToDateTime(_salaryDateE).AddDays(-1), DayOfWeek.Friday);
                            restDaysNow += TotalWeeks(StartTime, EndTime.AddDays(-1), DayOfWeek.Friday);
                        }
                        if (Convert.ToInt32(drAttendanceNow["Saturday"]) == 0)
                        {
                            restDaysMouth += TotalWeeks(Convert.ToDateTime(_salaryDateS),
                                Convert.ToDateTime(_salaryDateE).AddDays(-1), DayOfWeek.Saturday);
                            restDaysNow += TotalWeeks(StartTime, EndTime.AddDays(-1), DayOfWeek.Saturday);
                        }
                        if (Convert.ToInt32(drAttendanceNow["Sunday"]) == 0)
                        {
                            restDaysMouth += TotalWeeks(Convert.ToDateTime(_salaryDateS),
                                Convert.ToDateTime(_salaryDateE).AddDays(-1), DayOfWeek.Sunday);
                            restDaysNow += TotalWeeks(StartTime, EndTime.AddDays(-1), DayOfWeek.Sunday);
                        }
                    }
                    else  //反之，无论月可休息日以及阶段可休息日统一为可休息天数
                    {
                        restDaysNow = Convert.ToInt32(drAttendanceNow["RestDays"]);
                        restDaysMouth = Convert.ToInt32(drAttendanceNow["RestDays"]);
                    }
                }
                else
                {
                    //如果没有考核策略，那么直接月基本工资/月应出勤天数*履历天数
                    return 0;
                }
                //用结算天数-休息天数(月)，得出应出勤天数（月）
                int AttendanceDayMouth = _mouthDay - restDaysMouth;
                //基本工资（月）/应出勤天数（月），得出日工资
                daySalrty = Math.Round(Convert.ToDecimal(BasicSalaryMouth / AttendanceDayMouth), 2);

                //获取该工种持续时间的出勤情况
                DataTable dtStaffAttendance = _dsBase.Tables[1].Copy();
                dtStaffAttendance.DefaultView.RowFilter = " StaffID = " + StaffId;
                DataTable dtStaffAttendanceNow = dtStaffAttendance.DefaultView.ToTable();
                double realDay = 0;  //实际出勤天数
                foreach (DataRow drFor in dtStaffAttendanceNow.Rows)
                {
                    int Status = Convert.ToInt32(drFor["AttendanceStatus"]);
                    DateTime AttendanceDate = Convert.ToDateTime(drFor["AttendanceDate"]);
                    if (AttendanceDate >= StartTime && AttendanceDate < EndTime)  //必须是此工种持续时间范围内的
                    {
                        if (Status == 1)
                        {
                            realDay += 1;
                        }
                        else if (Status == 2)
                        {
                            realDay += 0.5;
                        }
                    }
                }
                double QDay = JobsDay - realDay;     //缺勤天数
                double SQDay = QDay - restDaysNow;               //实际缺勤天数（缺勤天数 - 休息天数）
                decimal KMoney = 0;

                //最终判断
                //如果出勤扣罚的类型是工资百分比，那么直接计算出勤天数即可
                //反之如果是阶梯扣罚，那么就要用日工资*工种阶段天数 - 缺勤天数对应的阶梯扣罚单价*缺勤天数
                if (PunishMode == 1)
                {
                    //如果实际出勤天数大于等于应出勤天数，直接满勤即可。
                    if (AttendanceDayMouth <= Convert.ToDecimal(realDay))
                    {
                        BisicSalary += BasicSalaryMouth;
                    }
                    else
                    {
                        BisicSalary += Convert.ToDecimal(realDay) * daySalrty;
                    }
                    if (SQDay > 0)
                    {
                        KMoney = Convert.ToDecimal(SQDay) * daySalrty;
                    }
                    else
                    {
                        KMoney += 0;
                    }
                }
                else
                {
                    //阶梯扣罚单价
                    decimal ladderPrice = 0;
                    //遍历获取到的阶梯扣罚区间，当实际缺勤天数小于零，要计算缺勤阶梯价格
                    if (SQDay > 0)
                    {
                        foreach (DataRow drFor in dtAttendanceNow.Rows)
                        {
                            int StartDay = Convert.ToInt32(drFor["BeginAbsentDays"]);
                            int EndDay = Convert.ToInt32(drFor["EndAbsentDays"]);
                            if (SQDay >= StartDay && SQDay <= EndDay)
                            {
                                ladderPrice = Convert.ToDecimal(drFor["PunishAmount"]);
                            }
                        }
                        BisicSalary += BasicSalaryMouth - ladderPrice * Convert.ToDecimal(SQDay);
                        KMoney += ladderPrice * Convert.ToDecimal(SQDay);
                    }
                    else //如果没有缺勤甚至还存在加班的话，暂不算加班时间，即(应出勤天数 - 应休息天数) * 日工资
                    {
                        BisicSalary += BasicSalaryMouth;
                        KMoney += 0;
                    }
                }

                #region 此阶段结算完毕后，要向数据集中添加数据(基本工资明细)。
                //基本工资明细
                DataRow drBasicSalary = _dtBasicSalary.NewRow();
                drBasicSalary["StaffID"] = StaffId;
                drBasicSalary["JobsID"] = JobsId;
                drBasicSalary["SalaryType"] = JobsStatus;
                drBasicSalary["BeginDate"] = StartTime;
                drBasicSalary["EndDate"] = EndTime;
                drBasicSalary["BasicSalary"] = BisicSalary;
                drBasicSalary["Subsidy"] = Subsidy;
                drBasicSalary["CheckedDays"] = AttendanceDayMouth;
                drBasicSalary["AttendanceDays"] = realDay;
                drBasicSalary["AbsenceDays"] = SQDay > 0 ? SQDay : 0;
                drBasicSalary["FineAmount"] = KMoney;
                drBasicSalary["TotalAmount"] = BisicSalary + Subsidy;
                _dtBasicSalary.Rows.Add(drBasicSalary);
                #endregion

                return BisicSalary + Subsidy;
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }

        public decimal GetASalaryByJobsId(int StaffId, int JobsId, int JobsStatus, DateTime StartTime, DateTime EndTime)
        {
            try
            {
                //该员工行政考核总额
                decimal ASalary = 0;
                //获取该员工相关的行政奖惩信息
                DataTable dtAdmin = _dsBase.Tables[2].Copy();
                dtAdmin.DefaultView.RowFilter = " StaffId = " + StaffId;
                DataTable dtAdminNow = dtAdmin.DefaultView.ToTable();
                //获取全部行政考核策略明细,并根据工种和员工状态筛选
                DataTable dtAdminDetail = _dsStrategy.Tables[5].Copy();
                dtAdminDetail.DefaultView.RowFilter = " JobsID = " + JobsId + " and SalaryType = " + (JobsStatus - 1);
                DataTable dtAdminDetailNow = dtAdminDetail.DefaultView.ToTable();
                if (dtAdminDetailNow.Rows.Count != 0)
                {
                    //如果有对应策略,那么遍历这些策略明细
                    foreach (DataRow drAdminDetailFor in dtAdminDetailNow.Rows)
                    {
                        //获取该策略明细的基础金额以及是否扣完的标签
                        decimal BaseAmount = Convert.ToDecimal(drAdminDetailFor["BaseAmount"]);
                        int IsEnd = Convert.ToInt32(drAdminDetailFor["IsEnd"]);
                        decimal TotalAmount = BaseAmount;
                        decimal RAPAmount = 0;
                        //并进一步过滤行政奖惩信息(根据该策略的行政考核类别)
                        dtAdminNow.DefaultView.RowFilter = " AdministrationType = " + drAdminDetailFor["AdministrationType"];
                        DataTable dtAdminNowByAType = dtAdminNow.DefaultView.ToTable();
                        //然后遍历该时间段内的该策略对应的考核类别的奖惩信息,进行加减运算
                        foreach (DataRow drFor in dtAdminNowByAType.Rows)
                        {
                            //遍历每一条奖惩信息,如果在该履历变动时间范围内并且奖惩类别相同的话,就根据字段进行加减运算
                            DateTime dtAuditDate = Convert.ToDateTime(drFor["AccountDate"]);
                            if (dtAuditDate >= StartTime && dtAuditDate <= EndTime)
                            {
                                RAPAmount += Convert.ToDecimal(drFor["RAPType"]) * Convert.ToDecimal(drFor["RAPAmount"]);
                                //添加明细
                                DataRow drAddSsmAdminDetail = _dtAdminDetail.NewRow();
                                drAddSsmAdminDetail["AdminRAPID"] = drFor["RAPID"];
                                drAddSsmAdminDetail["StaffID"] = StaffId;
                                //在AdminID字段中存一个策略ID,以便在后台插入时,区分哪些明细对应哪个策略
                                drAddSsmAdminDetail["AdminID"] = drAdminDetailFor["AdministrationID"];
                                drAddSsmAdminDetail["AccountId"] = drAdminDetailFor["SalaryType"];
                                drAddSsmAdminDetail["StaffSalaryID"] = drAdminDetailFor["JobsId"];

                                _dtAdminDetail.Rows.Add(drAddSsmAdminDetail);
                            }
                        }
                        //遍历完成后,根据结果以及扣完为止的标签,对总值进行相加
                        TotalAmount = BaseAmount + RAPAmount;
                        if (IsEnd == 1 && TotalAmount < 0)
                        {
                            TotalAmount = 0;
                        }
                        ASalary += TotalAmount;
                        //保存行政考核结算信息
                        DataRow drAddSsmAdmin = _dtAdmin.NewRow();
                        drAddSsmAdmin["StaffID"] = StaffId;
                        drAddSsmAdmin["JobsID"] = JobsId;
                        drAddSsmAdmin["SalaryType"] = JobsStatus - 1;
                        drAddSsmAdmin["BeginDate"] = _salaryDateS;
                        drAddSsmAdmin["EndDate"] = _salaryDateE;
                        drAddSsmAdmin["TATAdminID"] = drAdminDetailFor["AdministrationID"];
                        drAddSsmAdmin["AdministrationType"] = drAdminDetailFor["AdministrationType"];
                        drAddSsmAdmin["BaseAmount"] = BaseAmount;
                        drAddSsmAdmin["IsEnd"] = IsEnd;
                        drAddSsmAdmin["RAPAmount"] = RAPAmount;
                        drAddSsmAdmin["TotalAmount"] = TotalAmount;
                        _dtAdmin.Rows.Add(drAddSsmAdmin);
                    }
                }
                else
                {
                    return 0;
                }

                return ASalary;
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }

        public decimal GetPSalaryByJobsId(int StaffId, int JobsId, int JobsStatus, DateTime StartTime, DateTime EndTime)
        {
            try
            {
                //该员工进度考核总额
                decimal PSalary = 0;

                //获取该员工相关的进度奖惩信息
                DataTable dtProgress = _dsBase.Tables[4].Copy();
                dtProgress.DefaultView.RowFilter = " StaffId = " + StaffId;
                DataTable dtProgressNow = dtProgress.DefaultView.ToTable();
                //获取全部行政考核策略明细,并根据工种和员工状态筛选
                DataTable dtProgressDetail = _dsStrategy.Tables[6].Copy();
                dtProgressDetail.DefaultView.RowFilter = " JobsID = " + JobsId + " and SalaryType = " + (JobsStatus - 1);
                DataTable dtProgressDetailNow = dtProgressDetail.DefaultView.ToTable();
                if (dtProgressDetailNow.Rows.Count != 0)
                {
                    //如果有对应策略,那么遍历这些策略明细
                    foreach (DataRow drProgressDetailFor in dtProgressDetailNow.Rows)
                    {
                        //获取该策略明细的基础金额以及是否扣完的标签
                        decimal BaseAmount = Convert.ToDecimal(drProgressDetailFor["BaseAmount"]);
                        int IsEnd = Convert.ToInt32(drProgressDetailFor["IsEnd"]);
                        decimal TotalAmount = BaseAmount;
                        decimal RAPAmount = 0;
                        //然后遍历该时间段内的该策略对应的奖惩信息,进行加减运算
                        foreach (DataRow drFor in dtProgressNow.Rows)
                        {
                            //遍历每一条奖惩信息,如果在该履历变动时间范围内并且奖惩类别相同的话,就根据字段进行加减运算
                            DateTime dtAuditDate = Convert.ToDateTime(drFor["AccountDate"]);
                            if (dtAuditDate >= StartTime && dtAuditDate <= EndTime)
                            {
                                RAPAmount += Convert.ToDecimal(drFor["RAPType"]) * Convert.ToDecimal(drFor["RAPAmount"]);
                                //添加明细
                                DataRow drAddSsmProgressDetail = _dtProgressDetail.NewRow();
                                drAddSsmProgressDetail["ProgressRAPID"] = drFor["RAPID"];
                                drAddSsmProgressDetail["StaffID"] = StaffId;
                                //将工种以及状态保存起来，后台录入时，区分明细归属于哪个主体信息
                                drAddSsmProgressDetail["ProgressID"] = drProgressDetailFor["JobsId"];
                                drAddSsmProgressDetail["AccountID"] = drProgressDetailFor["SalaryType"];
                                _dtProgressDetail.Rows.Add(drAddSsmProgressDetail);
                            }
                        }
                        //遍历完成后,根据结果以及扣完为止的标签,对总值进行相加
                        TotalAmount = BaseAmount + RAPAmount;
                        if (IsEnd == 1 && TotalAmount < 0)
                        {
                            continue;
                        }
                        else
                        {
                            PSalary += TotalAmount;
                        }
                        //保存行政考核结算信息
                        DataRow drAddSsmProgress = _dtProgress.NewRow();
                        drAddSsmProgress["StaffID"] = StaffId;
                        drAddSsmProgress["JobsID"] = JobsId;
                        drAddSsmProgress["SalaryType"] = JobsStatus - 1;
                        drAddSsmProgress["BeginDate"] = _salaryDateS;
                        drAddSsmProgress["EndDate"] = _salaryDateE;
                        drAddSsmProgress["TATProgressID"] = drProgressDetailFor["ProgressID"];
                        drAddSsmProgress["BaseAmount"] = BaseAmount;
                        drAddSsmProgress["IsEnd"] = IsEnd;
                        drAddSsmProgress["RAPAmount"] = RAPAmount;
                        drAddSsmProgress["TotalAmount"] = TotalAmount;
                        _dtProgress.Rows.Add(drAddSsmProgress);
                    }
                }
                else
                {
                    return 0;
                }

                return PSalary;
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }

        private void CreateTable()
        {
            try
            {
                //首先根据主ID查询工资总汇数据集，如果是新建结算那么主ID会等于零，即查回一个空集。
                //（包括其他各项工资明细的集合,目的是在添加时可直接向表中添加内容）
                DataSet dsSourse = HRModuleProxy.Service.GetSettlementDetail(_mainId);
                _dtStaffSalary = dsSourse.Tables[0];
                if (_mainId == 0) //只有在新建时，才带回这些表结构，调整时是不允许修改这些的
                {
                    _dtBasicSalary = dsSourse.Tables[1];
                    _dtAttendance = dsSourse.Tables[2];
                    _dtWages = dsSourse.Tables[3];
                    _dtDefectFine = dsSourse.Tables[4];
                    _dtScrapFine = dsSourse.Tables[5];
                    _dtAdmin = dsSourse.Tables[6];
                    _dtAdminDetail = dsSourse.Tables[7];
                    _dtProgress = dsSourse.Tables[8];
                    _dtProgressDetail = dsSourse.Tables[9];
                    _dtManagerSalary = dsSourse.Tables[10];
                }
                else
                {
                    _dtMain = dsSourse.Tables[1];
                }
            }
            catch(Exception ex)
            {
                throw ex;
            }
        }

        private void dgvSettlement_CellDoubleClick(object sender, DataGridViewCellEventArgs e)
        {
            try
            {

                if (this.dgvSettlement.Rows[e.RowIndex].Cells["StaffSalaryID"].Value != DBNull.Value &&
                    this.dgvSettlement.Rows[e.RowIndex].Cells["StaffSalaryID"].Value != null)
                {
                    int StaffSalaryId = Convert.ToInt32(this.dgvSettlement.Rows[e.RowIndex].Cells["StaffSalaryID"].Value);
                    int StaffId = Convert.ToInt32(this.dgvSettlement.Rows[e.RowIndex].Cells["StaffId"].Value);
                    string StaffName = this.dgvSettlement.Rows[e.RowIndex].Cells["StaffName"].Value.ToString();

                    //以新建模式打开信息窗体
                    F_HR_1203 frmHR1203 = new F_HR_1203(StaffSalaryId, StaffId, StaffName);
                    DialogResult dialogResult = frmHR1203.ShowDialog();
                }
            }
            catch (Exception ex)
            {
                // 对异常进行共通处理
                ExceptionManager.HandleEventException(this.ToString(),
                System.Reflection.MethodBase.GetCurrentMethod().Name, this.Text, ex);
            }
        }

        private void dgvSettlement_CellValueChanged(object sender, DataGridViewCellEventArgs e)
        {
            try
            {
                if (e.RowIndex != -1)
                {
                    DataGridViewRow gvrNow = this.dgvSettlement.Rows[e.RowIndex];
                    //调整金额改变
                    if (this.dgvSettlement.Columns[e.ColumnIndex].Name == "AdjustmentAmount")
                    {
                        gvrNow.Cells["TotalAmount"].Value = Convert.ToDecimal(gvrNow.Cells["SettlementAmount"].Value)
                            + Convert.ToDecimal(gvrNow.Cells["AdjustmentAmount"].Value);
                    }
                }
            }
            catch(Exception ex)
            {
                // 对异常进行共通处理
                ExceptionManager.HandleEventException(this.ToString(),
                System.Reflection.MethodBase.GetCurrentMethod().Name, this.Text, ex);
            }
        }

        /// <summary>
        /// 获取调整总金额与合计总金额
        /// </summary>
        private void GetAdjustmentAmount()
        {
            foreach(DataGridViewRow gvrFor in this.dgvSettlement.Rows)
            {
                _adjustmentAmount += Convert.ToDecimal(gvrFor.Cells["AdjustmentAmount"].Value);
                if (_formType == Constant.FormMode.Edit)
                {
                    _salaryTotalMoney += Convert.ToDecimal(gvrFor.Cells["SettlementAmount"].Value);
                }
            }
        }

        private void btnSettlement_Click(object sender, EventArgs e)
        {
            try
            {
                GetBaseData();

                if(_nowSettlement == 1)
                {
                    this.btnSettlement.Enabled = false;
                }
                else
                {
                    this.btnSettlement.Enabled = true;
                }
            }
            catch (Exception ex)
            {
                // 对异常进行共通处理
                ExceptionManager.HandleEventException(this.ToString(),
                    System.Reflection.MethodBase.GetCurrentMethod().Name, this.Text, ex);
            }
        }

        private void btnSelect_Click(object sender, EventArgs e)
        {
            try
            {
                if (_nowSettlement == 0)
                {
                    MessageBox.Show("当前页未成功进行结算，无法进行筛选!",
                                this.Text, MessageBoxButtons.OK, MessageBoxIcon.Information);
                    return;
                }
                else
                {
                    StringBuilder sbRow = new StringBuilder();
                    sbRow.Append (" 1=1");
                    if(!string.IsNullOrEmpty(this.txtName.Text))
                    {
                        sbRow.Append("and StaffName like '%" + this.txtName.Text + "%'");
                    }
                    if(!string.IsNullOrEmpty(this.txtOrg.Text))
                    {
                        sbRow.Append("and OrganizationName like '%" + this.txtOrg.Text + "%'");
                    }

                    _dtStaffSalary.DefaultView.RowFilter = sbRow.ToString();
                    this.dgvSettlement.IsSetInputColumnsColor = true;
                }
            }
            catch(Exception ex)
            {
                // 对异常进行共通处理
                ExceptionManager.HandleEventException(this.ToString(),
                    System.Reflection.MethodBase.GetCurrentMethod().Name, this.Text, ex);
            }
        }
    }
}