/*******************************************************************************
 * Copyright(c) 2014 DongkeSoft All rights reserved. / Confidential
 * 类的信息：
 *      1.程序名称：TATModuleService.cs
 *      2.功能描述：策略管理模块WCF服务
 * 编辑履历：
 *      作者            日期                版本            修改内容
 *      庄天威          2014/11/18          1.00            新建
 *******************************************************************************/
using System;
using System.Data;
using System.ServiceModel;
using System.Collections.Generic;

using Dongke.IBOSS.PRD.Service.TATModuleLogic;
using Dongke.IBOSS.PRD.WCF.Contracts;
using Dongke.IBOSS.PRD.WCF.DataModels;
using Dongke.IBOSS.PRD.Service.PDAModuleLogic;
using System.ServiceModel.Activation;

namespace Dongke.IBOSS.PRD.WCF.Services
{
	// 服务实现类,继承服务声明接口
	// 该标签声明该服务可以在ASP.NET下运行
	[AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    [ServiceBehavior(ConfigurationName = "TATModuleService",
    InstanceContextMode = InstanceContextMode.PerCall,
    ConcurrencyMode = ConcurrencyMode.Multiple,
    UseSynchronizationContext = false)]
    public class TATModuleService : ServicesBase,ITATModule
    {
        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        public TATModuleService()
            : base()
        {
        }
        #endregion

        #region 缺陷扣罚

        /// <summary>
        /// 新建缺陷扣罚策略
        /// </summary>
        /// <param name="dfEntity">新建实体</param>
        /// <returns>
        /// 受影响行数
        /// </returns>
        public ServiceResultEntity AddDefectFine(DefectFineEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AddDefectFine(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 修改缺陷扣罚策略
        /// </summary>
        /// <param name="dfEntity">修改实体</param>
        /// <returns>
        /// 受影响行数
        /// </returns>
        public ServiceResultEntity UpdateDefectFine(DefectFineEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.UpdateDefectFine(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 审批缺陷扣罚策略
        /// </summary>
        /// <param name="dfEntity">审批策略实体</param>
        /// <returns>
        /// 返回受影响行数
        /// -999为策略开始月小于系统结算月,
        /// -998为存在同类别同开始日期策略.
        /// </returns>
        public ServiceResultEntity AuditDefectFine(DefectFineEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AuditDefectFine(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 停用缺陷扣罚策略
        /// </summary>
        /// <param name="dfEntity">停用实体</param>
        /// <returns>返回影响行</returns>
        public ServiceResultEntity StopDefectFine(DefectFineEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.StopDefectFine(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 查询缺陷扣罚信息
        /// </summary>
        /// <param name="dfEntity">查询条件实体</param>
        /// <returns>查询结果集</returns>
        public ServiceResultEntity GetDefectFine(DefectFineEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetDefectFine(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 根据主信息ID获取明细信息
        /// </summary>
        /// <param name="DefectId">主信息ID</param>
        /// <returns>数据集中两个Table，第一个是工种集合，第二个是全部信息</returns>
        public ServiceResultEntity GetDefectFineDetailById(int DefectId)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetDefectFineDetailById(DefectId));
        }

        /// <summary>
        /// 编辑缺陷扣罚的明细信息
        /// </summary>
        /// <param name="DefectFineID">缺陷扣罚主信息ID</param>
        /// <param name="dsSourse">明细数据源</param>
        /// <param name="userInfo">用户信息</param>
        /// <returns>结果</returns>
        public ServiceResultEntity EditDefectFineDetail(int DefectFineID, DataSet dsSourse)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.EditDefectFineDetail(DefectFineID, dsSourse, SUserInfo));
        }

        #endregion

        #region 基本工资策略
        /// <summary>
        /// 查询基本工资策略信息
        /// </summary>
        /// <param name="basicSalaryEntity">查询条件实体</param>
        /// <returns>查询结果实体</returns>
        /// <remarks>
        /// 2014.12.11			任海			新建
        /// </remarks>
        public ServiceResultEntity GetBasicSalary(BasicSalaryEntity basicSalaryEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetBasicSalary(basicSalaryEntity, SUserInfo));
        }

        /// <summary>
        /// 新建基本工资策略
        /// </summary>
        /// <param name="dfEntity">新建实体</param>
        /// <returns>受影响行数</returns>
        /// <remarks>
        /// 2014.12.11			任海			新建
        /// </remarks>
        public ServiceResultEntity AddBasicSalary(BasicSalaryEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AddBasicSalary(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 编辑基本工资策略
        /// </summary>
        /// <param name="dfEntity">新建实体</param>
        /// <returns>受影响行数</returns>
        /// <remarks>
        /// 2014.12.11			任海			新建
        /// </remarks>
        public ServiceResultEntity UpdateBasicSalary(BasicSalaryEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.UpdateBasicSalary(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 审批基本工资策略
        /// </summary>
        /// <param name="dfEntity">审批策略实体</param>
        /// <returns>
        /// 返回受影响行数
        /// </returns>
        /// <remarks>
        /// 2014.12.13			任海			新建
        /// </remarks>
        public ServiceResultEntity AuditBasicSalary(BasicSalaryEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AuditBasicSalary(dfEntity, SUserInfo));
        }


        /// <summary>
        /// 停用基本工资策略
        /// </summary>
        /// <param name="dfEntity">停用实体</param>
        /// <returns>返回影响行</returns>
        /// <remarks>
        /// 2014.12.13			任海			新建
        /// </remarks>
        public ServiceResultEntity StopBasicSalary(BasicSalaryEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.StopBasicSalary(dfEntity, SUserInfo));
        }



        /// <summary>
        /// 查询基本工资策略明细
        /// </summary>
        /// <param name="BasicSalaryID">主信息ID</param>
        /// <returns>服务实体对象,包含工种明细数据源</returns>
        /// <param name="userInfo">当前用户信息</param>
        /// <remarks>
        /// 2014.12.12			任海			新建
        /// </remarks>
        public ServiceResultEntity GetBasicSalaryDetailById(int BasicSalaryID)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetBasicSalaryDetailById(BasicSalaryID, SUserInfo));
        }

        /// <summary>
        /// 编辑保存基本工资对应工种明细
        /// </summary>
        /// <param name="BasicSalaryID">工价策略ID</param>
        /// <param name="dsDetail">对应工种数据源</param>
        /// <param name="userInfo">当前用户</param>
        /// <returns>服务对象实体</returns>
        /// <remarks>
        /// 2014.12.11			任海			新建
        /// </remarks>
        public ServiceResultEntity EditBasicSalaryDetail(int BasicSalaryID, DataSet dsDetail)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.EditBasicSalaryDetail(BasicSalaryID, dsDetail, SUserInfo, null));
        }
        #endregion

        #region 出勤考核
        /// <summary>
        /// 查询出勤考核信息
        /// </summary>
        /// <param name="attendanceEntity">查询条件实体</param>
        /// <returns>查询结果实体</returns>
        /// <remarks>
        /// 2014.12.15			任海			新建
        public ServiceResultEntity GetAttendance(AttendanceEntity attendanceEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetAttendance(attendanceEntity, SUserInfo));
        }

        /// <summary>
        /// 查询出勤考核的明细对应工种
        /// </summary>
        /// <param name="AttendanceID">主信息ID</param>
        /// <returns>服务实体对象,包含工种明细数据源</returns>
        /// <param name="userInfo">当前用户信息</param>
        /// <remarks>
        /// 2014.12.16			任海			新建
        /// </remarks>
        public ServiceResultEntity GetAttendanceEntityById(int AttendanceID)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetAttendanceEntityById(AttendanceID, SUserInfo));
        }

        /// <summary>
        /// 新建出勤考核
        /// </summary>
        /// <param name="dfEntity">新建实体</param>
        /// <param name="userInfo">当前用户信息</param>
        /// <returns>受影响行数</returns>
        /// <remarks>
        /// 2014.12.15			任海			新建
        /// </remarks>
        public ServiceResultEntity AddAttendance(AttendanceEntity dfEntity, DataSet dsDetail)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AddAttendance(dfEntity,dsDetail, SUserInfo));
        }

        /// <summary>
        /// 修改出勤考核信息
        /// </summary>
        /// <param name="dfEntity">修改实体</param>
        /// <param name="userInfo">当前用户信息</param>
        /// <returns>受影响行数</returns>
        /// <remarks>
        /// 2014.12.15			任海			新建
        /// </remarks>
        public ServiceResultEntity UpdateAttendance(AttendanceEntity dfEntity, DataSet dsDetail)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.UpdateAttendance(dfEntity,dsDetail, SUserInfo));
        }

        /// <summary>
        /// 停用出勤考核
        /// </summary>
        /// <param name="dfEntity">停用实体</param>
        /// <param name="userInfo">当前用户信息</param>
        /// <returns>返回影响行</returns>
        public ServiceResultEntity StopAttendance(AttendanceEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.StopAttendance(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 审批出勤考核
        /// </summary>
        /// <param name="dfEntity">审批出勤考核实体</param>
        /// <param name="userInfo">当前用户</param>
        /// <returns>
        /// 返回受影响行数
        /// -999为策略开始月小于系统结算月,
        /// -998为存在同类别同开始日期策略.
        /// </returns>
        public ServiceResultEntity AuditAttendance(AttendanceEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AuditAttendance(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 查询出勤考核明细的信息
        /// </summary>
        /// <param name="attendanceDetailEntity">查询条件实体</param>
        /// <param name="userInfo">当前用户信息</param>
        /// <returns>查询结果实体</returns>
        /// <remarks>
        /// 2014.12.18			任海			新建
        public ServiceResultEntity GetAttendanceDetail(AttendanceDetailEntity attendanceDetailEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetAttendanceDetail(attendanceDetailEntity, SUserInfo));
        }

        /// <summary>
        /// 查询出勤考核的明细对应扣款
        /// </summary>
        /// <param name="AttendanceID">主信息ID</param>
        /// <returns>服务实体对象,包含工种明细数据源</returns>
        /// <param name="userInfo">当前用户信息</param>
        /// <remarks>
        /// 2014.12.18			任海			新建
        /// </remarks>
        public ServiceResultEntity GetAttFinesRulesById(int AttendanceID, int JobsID)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetAttFinesRulesById(AttendanceID,JobsID, SUserInfo));
        }

        /// <summary>
        /// 编辑出勤考核明细
        /// </summary>
        /// <param name="attendanceDetailEntity">工价实体</param>
        /// <param name="dsDetail">工价对应工种关系数据源</param>
        /// <param name="userInfo">当前用户</param>
        /// <returns>服务对象实体</returns>
        public ServiceResultEntity EditAttendanceDetail(AttendanceDetailEntity attendanceDetailEntity, DataSet dsDetail)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.EditAttendanceDetail(attendanceDetailEntity, dsDetail, SUserInfo));
        }
        #endregion

        #region 工价策略
        /// <summary>
        /// 查询工价策略信息
        /// </summary>
        /// <param name="dfEntity">查询条件实体</param>
        /// <returns>查询结果实体</returns>
        public ServiceResultEntity GetWages(WagesEntity wagesEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetWages(wagesEntity, SUserInfo));
        }

        /// <summary>
        /// 根据工价策略主信息ID获取对应工种明细信息
        /// </summary>
        /// <param name="DefectId">主信息ID</param>
        /// <returns>服务实体对象,包含工种明细数据源</returns>
        public ServiceResultEntity GetWagesDetailById(int WagesId)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetWagesDetailById(WagesId));
        }

        /// <summary>
        /// 根据工价策略主信息ID以及对应的工种ID获取对应的产品设定数据源
        /// </summary>
        /// <param name="WagesId">工价策略主ID</param>
        /// <param name="JobsId">对应工种ID</param>
        /// <returns>包含对应产品数据源的服务返回实体</returns>
        public ServiceResultEntity GetWagesGoodsDetail(int WagesId, int JobsId)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetWagesGoodsDetail(WagesId, JobsId));
        }

        /// <summary>
        /// 新建工价策略
        /// </summary>
        /// <param name="wagesEntity">新建实体</param>
        /// <param name="dsDetail">对应工种明细</param>
        /// <returns>服务返回实体</returns>
        public ServiceResultEntity AddWages(WagesEntity wagesEntity, DataSet dsDetail)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AddWages(wagesEntity, dsDetail, SUserInfo));
        }

        /// <summary>
        /// 编辑工价策略
        /// </summary>
        /// <param name="wagesEntity">工价实体</param>
        /// <param name="dsDetail">工价对应工种关系数据源</param>
        /// <returns>服务对象实体</returns>
        public ServiceResultEntity EditWages(WagesEntity wagesEntity, DataSet dsDetail)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.EditWages(wagesEntity, dsDetail, SUserInfo));
        }

        /// <summary>
        /// 审批工价策略
        /// </summary>
        /// <param name="wagesEntity">工价策略实体</param>
        /// <returns>
        /// 返回受影响行数
        /// -999为策略开始月小于系统结算月,
        /// -998为存在同类别同开始日期策略.
        /// </returns>
        public ServiceResultEntity AuditWages(WagesEntity wagesEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AuditWages(wagesEntity, SUserInfo));
        }

        /// <summary>
        /// 停用工价策略
        /// </summary>
        /// <param name="wagesEntity">停用实体</param>
        /// <returns>返回影响行</returns>
        public ServiceResultEntity StopWages(WagesEntity wagesEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.StopWages(wagesEntity, SUserInfo));
        }

        /// <summary>
        /// 编辑工价对应工种明细
        /// </summary>
        /// <param name="WagesID">工价策略ID</param>
        /// <param name="dsDetail">对应工种数据源</param>
        /// <param name="oracleTrConn">事务链接</param>
        /// <returns>服务对象实体</returns>
        public ServiceResultEntity EditWagesDetail(int WagesID, DataSet dsDetail)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.EditWagesDetail(WagesID, dsDetail, SUserInfo, null));
        }

        /// <summary>
        /// 编辑工价对应的产品明细
        /// </summary>
        /// <param name="WagesID">工价策略ID</param>
        /// <param name="JobsID">对应工种ID</param>
        /// <param name="dsDetail">数据源</param>
        /// <returns>服务返回实体</returns>
        public ServiceResultEntity EditWagesGoodsDetail(int WagesID, int JobsID, DataSet dsDetail)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.EditWagesGoodsDetail(WagesID, JobsID, dsDetail, SUserInfo));
        }

        #endregion

        #region 质量考核

        /// <summary>
        /// 新建质量考核策略
        /// </summary>
        /// <param name="dfEntity">新建实体</param>
        /// <returns>
        /// 受影响行数
        /// </returns>
        public ServiceResultEntity AddQuality(QualityEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AddQuality(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 修改质量考核策略
        /// </summary>
        /// <param name="dfEntity">修改实体</param>
        /// <returns>
        /// 受影响行数
        /// </returns>
        public ServiceResultEntity UpdateQuality(QualityEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.UpdateQuality(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 审批质量考核策略
        /// </summary>
        /// <param name="dfEntity">审批策略实体</param>
        /// <returns>
        /// 返回受影响行数
        /// -999为策略开始月小于系统结算月,
        /// -998为存在同类别同开始日期策略.
        /// </returns>
        public ServiceResultEntity AuditQuality(QualityEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AuditQuality(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 停用质量考核策略
        /// </summary>
        /// <param name="dfEntity">停用实体</param>
        /// <returns>返回影响行</returns>
        public ServiceResultEntity StopQuality(QualityEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.StopQuality(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 查询质量考核信息
        /// </summary>
        /// <param name="dfEntity">查询条件实体</param>
        /// <returns>查询结果集</returns>
        public ServiceResultEntity GetQuality(QualityEntity quality)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetQuality(quality, SUserInfo));
        }

        /// <summary>
        /// 根据主信息ID获取明细信息
        /// </summary>
        /// <param name="QualityID">主信息ID</param>
        /// <returns>数据集中两个Table，第一个是工种集合，第二个是全部信息</returns>
        public ServiceResultEntity GetQualityDetailById(int qualityID)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetQualityDetailById(qualityID));
        }

        /// <summary>
        /// 编辑质量考核的明细信息
        /// </summary>
        /// <param name="QualityID">质量考核主信息ID</param>
        /// <param name="dsSourse">明细数据源</param>
        /// <param name="userInfo">用户信息</param>
        /// <returns>结果</returns>
        public ServiceResultEntity EditQualityDetail(int QualityID, DataSet dsSourse)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.EditQualityDetail(QualityID, dsSourse, SUserInfo));
        }

        #endregion

        #region 进度考核

        /// <summary>
        /// 新建进度考核策略
        /// </summary>
        /// <param name="dfEntity">新建实体</param>
        /// <returns>
        /// 受影响行数
        /// </returns>
        public ServiceResultEntity AddProgress(ProgressEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AddProgress(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 修改进度考核策略
        /// </summary>
        /// <param name="dfEntity">修改实体</param>
        /// <returns>
        /// 受影响行数
        /// </returns>
        public ServiceResultEntity UpdateProgress(ProgressEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.UpdateProgress(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 审批进度考核策略
        /// </summary>
        /// <param name="dfEntity">审批策略实体</param>
        /// <returns>
        /// 返回受影响行数
        /// -999为策略开始月小于系统结算月,
        /// -998为存在同类别同开始日期策略.
        /// </returns>
        public ServiceResultEntity AuditProgress(ProgressEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AuditProgress(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 停用进度考核策略
        /// </summary>
        /// <param name="dfEntity">停用实体</param>
        /// <returns>返回影响行</returns>
        public ServiceResultEntity StopProgress(ProgressEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.StopProgress(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 查询进度考核信息
        /// </summary>
        /// <param name="dfEntity">查询条件实体</param>
        /// <returns>查询结果集</returns>
        public ServiceResultEntity GetProgress(ProgressEntity progres)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetProgress(progres, SUserInfo));
        }

        /// <summary>
        /// 根据主信息ID获取明细信息
        /// </summary>
        /// <param name="ProgressID">主信息ID</param>
        /// <returns>数据集中两个Table，第一个是工种集合，第二个是全部信息</returns>
        public ServiceResultEntity GetProgressDetailById(int progresID)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetProgressDetailById(progresID));
        }

        /// <summary>
        /// 编辑进度考核的明细信息
        /// </summary>
        /// <param name="ProgressID">质量考核主信息ID</param>
        /// <param name="dsSourse">明细数据源</param>
        /// <param name="userInfo">用户信息</param>
        /// <returns>结果</returns>
        public ServiceResultEntity EditProgressDetail(int ProgressID, DataSet dsSourse)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.EditProgressDetail(ProgressID, dsSourse, SUserInfo));
        }

        #endregion

        #region 行政考核

        /// <summary>
        /// 新建行政考核策略
        /// </summary>
        /// <param name="dfEntity">新建实体</param>
        /// <returns>
        /// 受影响行数
        /// </returns>
        public ServiceResultEntity AddAdministration(AdministrationEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AddAdministration(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 修改行政考核策略
        /// </summary>
        /// <param name="dfEntity">修改实体</param>
        /// <returns>
        /// 受影响行数
        /// </returns>
        public ServiceResultEntity UpdateAdministration(AdministrationEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.UpdateAdministration(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 审批行政考核策略
        /// </summary>
        /// <param name="dfEntity">审批策略实体</param>
        /// <returns>
        /// 返回受影响行数
        /// -999为策略开始月小于系统结算月,
        /// -998为存在同类别同开始日期策略.
        /// </returns>
        public ServiceResultEntity AuditAdministration(AdministrationEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AuditAdministration(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 停用行政考核策略
        /// </summary>
        /// <param name="dfEntity">停用实体</param>
        /// <returns>返回影响行</returns>
        public ServiceResultEntity StopAdministration(AdministrationEntity dfEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.StopAdministration(dfEntity, SUserInfo));
        }

        /// <summary>
        /// 查询行政考核信息
        /// </summary>
        /// <param name="dfEntity">查询条件实体</param>
        /// <returns>查询结果集</returns>
        public ServiceResultEntity GetAdministration(AdministrationEntity administration)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetAdministration(administration, SUserInfo));
        }

        /// <summary>
        /// 根据主信息ID获取明细信息
        /// </summary>
        /// <param name="administrationID">主信息ID</param>
        /// <returns>数据集中两个Table，第一个是工种集合，第二个是全部信息</returns>
        public ServiceResultEntity GetAdminDetailEntityById(int administrationID)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetAdminDetailEntityById(administrationID));
        }

        /// <summary>
        /// 编辑行政考核的明细信息
        /// </summary>
        /// <param name="AdministrationID">行政考核ID</param>
        /// <param name="dsSourse">明细数据源</param>
        /// <param name="userInfo">用户信息</param>
        /// <returns>结果</returns>
        public ServiceResultEntity EditAdminDetail(int AdministrationID, DataSet dsSourse)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.EditAdminDetail(AdministrationID, dsSourse, SUserInfo));
        }

        #endregion

        #region 管理岗位工资策略
        /// <summary>
        /// 查询管理岗位工资策略信息
        /// </summary>
        /// <param name="msEntity">查询条件实体</param>
        /// <returns>查询结果实体</returns>
        public ServiceResultEntity GetManagerSalary(ManagerSalaryEntity msEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetManagerSalary(msEntity, SUserInfo));
        }

        /// <summary>
        /// 根据管理岗位工资策略主信息ID获取对应管理者信息
        /// </summary>
        /// <param name="ManagerSalaryID">主信息ID</param>
        /// <returns>服务实体对象,包含工种明细数据源</returns>
        public ServiceResultEntity GetManagersById(int ManagerSalaryID)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetManagersById(ManagerSalaryID));
        }

        /// <summary>
        /// 根据管理者信息ID获取对应的组内成员数据源
        /// </summary>
        /// <param name="ManagersID">工价策略主ID</param>
        /// <returns>包含对应产品数据源的服务返回实体</returns>
        public ServiceResultEntity GetMembers(int ManagersID)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogic.GetMembers(ManagersID));
        }

        /// <summary>
        /// 新建管理岗位工资策略
        /// </summary>
        /// <param name="msEntity">新建实体</param>
        /// <param name="dsDetail">对应管理者明细</param>
        /// <returns>服务返回实体</returns>
        public ServiceResultEntity AddManagerSalary(ManagerSalaryEntity msEntity, DataSet dsDetail)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AddManagerSalary(msEntity, dsDetail, SUserInfo));
        }

        /// <summary>
        /// 编辑管理岗位工资策略
        /// </summary>
        /// <param name="msEntity">策略实体</param>
        /// <param name="dsDetail">明细数据源</param>
        /// <returns>服务对象实体</returns>
        public ServiceResultEntity EditManagerSalary(ManagerSalaryEntity msEntity, DataSet dsDetail)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.EditManagerSalary(msEntity, dsDetail, SUserInfo));
        }

        /// <summary>
        /// 审批管理岗位工资策略
        /// </summary>
        /// <param name="msEntity">策略实体</param>
        /// <returns>
        /// 返回受影响行数
        /// -999为策略开始月小于系统结算月,
        /// -998为存在同类别同开始日期策略.
        /// </returns>
        public ServiceResultEntity AuditManagerSalary(ManagerSalaryEntity msEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.AuditManagerSalary(msEntity, SUserInfo));
        }

        /// <summary>
        /// 停用管理岗位工资策略
        /// </summary>
        /// <param name="msEntity">停用实体</param>
        /// <returns>返回影响行</returns>
        public ServiceResultEntity StopManagerSalary(ManagerSalaryEntity msEntity)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.StopManagerSalary(msEntity, SUserInfo));
        }

        /// <summary>
        /// 编辑管理组内成员明细
        /// </summary>
        /// <param name="ManagersID">管理岗位人员ID</param>
        /// <param name="dsDetail">数据源</param>
        /// <returns>服务返回实体</returns>
        public ServiceResultEntity EditMembers(int ManagerSalaryID, int ManagersID, DataSet dsDetail)
        {
            return ServiceInvoker.Invoke<ServiceResultEntity>(this, () => TATModuleLogicDAL.EditMembers(ManagerSalaryID, ManagersID, dsDetail, SUserInfo));
        }
        #endregion

        /// <summary>
        /// 获取全部使用中的策略明细数据集
        /// </summary>
        /// <param name="SalaryTimeS">结算时间起</param>
        /// <param name="userInfo">当前用户</param>
        /// <returns>各策略明细集</returns>
        public DataSet GetAllUseStrategy(DateTime SalaryTimeS)
        {
            return ServiceInvoker.Invoke<DataSet>(this, () => TATModuleLogic.GetAllUseStrategy(SalaryTimeS, SUserInfo));
        }

    }
}