IMEX.mes.wcf/WCF.Client/WCF.Proxys/TATModuleProxy.cs

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

namespace Dongke.IBOSS.PRD.WCF.Proxys
{
    public class TATModuleProxy : ServiceProxyBase<ITATModule>
    {
        #region 构造函数
        private TATModuleProxy()
            : base("TATModuleService")
        {
        }

        private static TATModuleProxy _service = null;

        public static TATModuleProxy Service
        {
            get
            {
                if (_service == null)
                {
                    return new TATModuleProxy();
                }

                return _service;
            }
        }
        #endregion

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

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

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

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

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

        /// <summary>
        /// 根据主信息ID获取明细信息
        /// </summary>
        /// <param name="DefectId">主信息ID</param>
        /// <returns>数据集中两个Table，第一个是工种集合，第二个是全部信息</returns>
        public ServiceResultEntity GetDefectFineDetailById(int DefectId)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.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 this.Invoker.Invoke<ServiceResultEntity>(p => p.EditDefectFineDetail(DefectFineID, dsSourse));
        }

        #endregion

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

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

        /// <summary>
        /// 编辑基本工资策略信息
        /// </summary>
        /// <param name="basicSalaryEntity">查询条件实体</param>
        /// <returns>查询结果实体</returns>
        /// <remarks>
        /// 2014.12.11			任海			新建
        /// </remarks>
        public ServiceResultEntity UpdateBasicSalary(BasicSalaryEntity dfEntity)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(proxy => proxy.UpdateBasicSalary(dfEntity));
        }

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

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


        /// <summary>
        /// 查询基本工资策略明细
        /// </summary>
        /// <param name="BasicSalaryID">主信息ID</param>
        /// <remarks>
        /// 2014.12.12			任海			新建
        /// </remarks>
        public ServiceResultEntity GetBasicSalaryDetailById(int BasicSalaryID)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(proxy => proxy.GetBasicSalaryDetailById(BasicSalaryID));
        }

        /// <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 this.Invoker.Invoke<ServiceResultEntity>(p => p.EditBasicSalaryDetail(BasicSalaryID, dsDetail));
        }
        #endregion

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

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

        /// <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 this.Invoker.Invoke<ServiceResultEntity>(proxy => proxy.UpdateAttendance(dfEntity, dsDetail));
        }

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

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

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

        /// <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 this.Invoker.Invoke<ServiceResultEntity>(proxy => proxy.GetAttFinesRulesById(AttendanceID, JobsID));
        }

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

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

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

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

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

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

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

        /// <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 this.Invoker.Invoke<ServiceResultEntity>(p => p.EditWagesDetail(WagesID, dsDetail));
        }

        /// <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 this.Invoker.Invoke<ServiceResultEntity>(p => p.EditWagesGoodsDetail(WagesID, JobsID, dsDetail));
        }

        #endregion

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

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

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

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

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

        /// <summary>
        /// 根据主信息ID获取明细信息
        /// </summary>
        /// <param name="qualityID">主信息ID</param>
        /// <returns>数据集中两个Table，第一个是工种集合，第二个是全部信息</returns>
        public ServiceResultEntity GetQualityDetailById(int qualityID)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.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 this.Invoker.Invoke<ServiceResultEntity>(p => p.EditQualityDetail(qualityID, dsSourse));
        }

        #endregion

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

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

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

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

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

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

        /// <summary>
        /// 编辑进度考核的明细信息
        /// </summary>
        /// <param name="progresID">缺陷扣罚主信息ID</param>
        /// <param name="dsSourse">明细数据源</param>
        /// <param name="userInfo">用户信息</param>
        /// <returns>结果</returns>
        public ServiceResultEntity EditProgressDetail(int progresID, DataSet dsSourse)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.EditProgressDetail(progresID, dsSourse));
        }

        #endregion

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

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

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

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

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

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

        #endregion

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

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

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

        /// <summary>
        /// 新建管理岗位工资策略
        /// </summary>
        /// <param name="msEntity">新建实体</param>
        /// <param name="dsDetail">对应管理者明细</param>
        /// <returns>服务返回实体</returns>
        public ServiceResultEntity AddManagerSalary(ManagerSalaryEntity msEntity, DataSet dsDetail)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.AddManagerSalary(msEntity, dsDetail));
        }
        
        /// <summary>
        /// 编辑管理岗位工资策略
        /// </summary>
        /// <param name="msEntity">策略实体</param>
        /// <param name="dsDetail">明细数据源</param>
        /// <returns>服务对象实体</returns>
        public ServiceResultEntity EditManagerSalary(ManagerSalaryEntity msEntity, DataSet dsDetail)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.EditManagerSalary(msEntity, dsDetail));
        }

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

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

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

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

    }
}