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

/*******************************************************************************
 * Copyright(c) 2014 DongkeSoft All rights reserved. / Confidential
 * 类的信息：
 *      1.程序名称：PMModuleProxy.cs
 *      2.功能描述：生产管理服务代理
 * 编辑履历：
 *      作者            日期                版本            修改内容
 *      陈晓野          2014/09/16          1.00            新建
 *******************************************************************************/

using System;
using System.Collections.Generic;
using System.Data;
using Dongke.IBOSS.PRD.WCF.DataModels;
using Dongke.IBOSS.PRD.WCF.DataModels.PMModule;
using Dongke.IBOSS.PRD.WCF.Proxys.PMModuleService;
using Dongke.IBOSS.PRD.WCF.Proxys.ServiceProxy;

namespace Dongke.IBOSS.PRD.WCF.Proxys
{
    /// <summary>
    /// 生产管理服务代理
    /// </summary>
    public class PMModuleProxy : ServiceProxyBase<IPMModule>
    {
        #region 构造

        private PMModuleProxy()
            : base("PMModuleService")
        {
        }

        private static PMModuleProxy _service = null;

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

                return _service;
            }
        }

        #endregion

        #region new
        #region 注浆登记

        /// <summary>
        /// 取得FPM0101画面（注浆登记）的查询数据
        /// </summary>
        /// <param name="se">查询条件</param>
        /// <returns>查询结果</returns>
        public DataSet GetFPM0101SData(FPM0101_SE se)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetFPM0101SData(se));
        }

        #endregion 注浆登记

        #endregion new


        #region 注浆日报

        /// <summary>
        /// 获得注浆日报表
        /// </summary>
        /// <param name="groutingDailyEntity">注浆日报实体</param>
        /// <returns>数据源Dataset</returns>
        /// <remarks>
        /// 庄天威              2014.09.10              新建
        /// </remarks>
        public DataSet GetGroutingDaily(GroutingDailyEntity dailyEntity)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetGroutingDaily(dailyEntity));
        }

        /// <summary>
        /// 获得注浆日报表明细(根据注浆日报表ID)
        /// </summary>
        /// <param name="DailyMainId">注浆日报主ID</param>
        /// <returns>Dataset数据源</returns>
        /// <remarks>
        /// 庄天威              2014.09.10              新建 
        /// </remarks>
        public DataSet GetGroutingDailyDetailByMainId(int DailyMainId)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetGroutingDailyDetailByMainId(DailyMainId));
        }

        /// <summary> 
        /// 新建注浆日报信息
        /// </summary>
        /// <param name="groutingDailyEntityList">注浆日报实体</param>
        /// <param name="dailyDetailEntityList">明细实体集合</param>
        /// <returns>int返回受影响行数</returns>
        /// <remarks>
        /// 庄天威              2014.09.20              新建
        /// </remarks>
        public int AddGroutingDaily(List<GroutingDailyEntity> dailyEntityList, List<GroutingDailyDetailEntity> dailyDetailEntityList)
        {
            return this.Invoker.Invoke<int>(p => p.AddGroutingDaily(dailyEntityList.ToArray(), dailyDetailEntityList.ToArray()));
        }

        /// <summary> 
        /// 修改注浆日报信息（明细）
        /// </summary>
        /// <param name="dailyDetailList">明细实体集合</param>
        /// <returns>int</returns>
        /// <remarks>
        /// 庄天威              2014.09.20              新建
        /// </remarks>
        public int UpdateGroutingDaily(List<GroutingDailyDetailEntity> dailyDetailList)
        {
            return this.Invoker.Invoke<int>(p => p.UpdateGroutingDaily(dailyDetailList.ToArray()));
        }

        /// <summary>
        /// 获得注浆产品(根据注浆日报明细ID)
        /// </summary>
        /// <param name="DailyDetailId">注浆日报明细ID</param>
        /// <returns>string条码字符串集合</returns>
        /// <remarks>
        /// 庄天威              2014.09.10              新建 
        /// </remarks>
        public string GetGroutingProductByDetailId(int DailyDetailId)
        {
            return this.Invoker.Invoke<string>(p => p.GetGroutingProductByDetailId(DailyDetailId));
        }

        /// <summary>
        /// 修改条码
        /// </summary>
        /// <param name="barCode">原条码</param>
        /// <param name="barCodeUpdate">新条码</param>
        /// <returns>int返回值结果</returns>
        public int UpdateBarCode(string barCode, string barCodeUpdate)
        {
            return this.Invoker.Invoke<int>(p => p.UpdateBarCode(barCode, barCodeUpdate));
        }

        /// <summary>
        /// 查看某成型线今天是否注浆
        /// </summary>
        /// <param name="GroutingLineID">成型线ID</param>
        /// <param name="GroutingDate">注浆时间</param>
        /// <returns>int</returns>
        /// <remarks>
        /// 庄天威              2014.09.29              新建 
        /// </remarks>
        public int GetCanManyTimes(int GroutingLineID, DateTime GroutingDate)
        {
            return this.Invoker.Invoke<int>(p => p.GetCanManyTimes(GroutingLineID, GroutingDate));
        }

        /// <summary>
        /// 根据成型线ID获取注浆明细信息（外联条码）
        /// </summary>
        /// <param name="GroutingLineIds">成型线ID集</param>
        /// <param name="GroutingDateStart">注浆时间起始</param>
        /// <param name="GroutingDateEnd">注浆时间终止</param>
        /// <returns>DataSet</returns>
        /// <remarks>
        /// 庄天威              2014.09.30              新建
        /// </remarks>
        public DataSet GetGDailyDetailLeftBarCode(string GroutingLineIds, DateTime? GroutingDateStart,
            DateTime? GroutingDateEnd)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetGDailyDetailLeftBarCode(GroutingLineIds, GroutingDateStart, GroutingDateEnd));
        }

        /// <summary>
        /// 根据注浆明细添加条码
        /// </summary>
        /// <param name="dailyDetailList">明细列表</param>
        /// <param name="ScrapIds">报废标记集</param>
        /// <returns>int</returns>
        /// <remarks>庄天威</remarks>
        public int AddBarCode(List<GroutingDailyDetailEntity> dailyDetailList, string ScrapIds)
        {
            return this.Invoker.Invoke<int>(p => p.AddBarCode(dailyDetailList.ToArray(), ScrapIds));
        }

        /// <summary> 
        /// 验证条码唯一性
        /// </summary>
        /// <param name="Barcode">需要验证的条码(多个，逗号分割)</param>
        /// <returns>string结果</returns>
        /// <remarks>
        /// 庄天威              2014.09.23              新建
        /// </remarks>
        public string BarCodesIsRepeat(String BarCodes)
        {
            return this.Invoker.Invoke<string>(p => p.BarCodesIsRepeat(BarCodes));
        }

        /// <summary>
        /// 获取某模具某天以前的最大注浆次数,方便补录数据
        /// </summary>
        /// <param name="MouldCode">模具编号</param>
        /// <param name="inTime">注浆时间</param>
        /// <returns>int最大注浆次数(如录入数据需+1)</returns>
        public int GetMaxGroutingCountByMouldCode(string MouldCode, DateTime inTime)
        {
            return this.Invoker.Invoke<int>(p => p.GetMaxGroutingCountByMouldCode(MouldCode, inTime));
        }

        /// <summary>
        /// 获取某一时间段的某成型线明细的模具编号
        /// </summary>
        /// <param name="GroutingLineDetailID">成型线明细ID</param>
        /// <param name="inTime">注浆时间</param>
        /// <returns>string</returns>
        public string GetMouldCodeFromHistoryByTime(int GroutingLineDetailID, DateTime inTime)
        {
            return this.Invoker.Invoke<string>(p => p.GetMouldCodeFromHistoryByTime(GroutingLineDetailID, inTime));
        }

        /// <summary>
        /// 条码检索
        /// </summary>
        /// <param name="gbEntity">条码检索实体</param>
        /// <returns>数据源Dataset</returns>
        /// <remarks>
        /// 庄天威              2014.09.10              新建
        /// </remarks>
        public DataSet GetBarCode(GetBarCodeEntity gbEntity)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetBarCode(gbEntity));
        }

        #endregion

        #region 废弃产品

        /// <summary>
        /// 根据条码获取该产品的在产信息以及生产数据
        /// </summary>
        /// <param name="Barcode">产品条码</param>
        /// <returns>装有两个DataTable的数据集，第一个是在产信息，第二个是生产数据</returns>
        public DataSet GetInProductionAndProductionData(string BarCode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetInProductionAndProductionData(BarCode));
        }

        /// <summary>
        /// 添加废弃产品记录
        /// </summary>
        /// <param name="SProductEntity">废弃产品实体</param>
        /// <param name="RProcedureEntity">废弃责任工序实体</param>
        /// <param name="SResponsibleList">责任者集合</param>
        /// <returns>int结果返回值</returns>
        /// <remarks>
        /// 庄天威              2014.09.24              新建
        /// </remarks>
        public int AddScrapProduct(ScrapProductEntity SProductEntity,
            ResponProcedureEntity RProcedureEntity,
            List<ScrapResponsibleEntity> SResponsibleList)
        {
            return this.Invoker.Invoke<int>(p => p.AddScrapProduct(SProductEntity, RProcedureEntity, SResponsibleList.ToArray()));
        }

        /// <summary>
        /// 修改废弃产品记录
        /// </summary>
        /// <param name="UpdateSProductEntity">修改的废弃产品实体</param>
        /// <param name="UpdateRProcedureEntity">修改的废弃责任工序实体</param>
        /// <param name="UpdateSResponsibleList">修改的废弃责任人实体</param>
        /// <param name="YSResponsibleList">修改前的废弃责任人实体</param>
        /// <returns>int结果返回值</returns>
        /// <remarks>
        /// 庄天威              2014.09.24              新建
        /// </remarks>
        public int UpdateScrapProduct(ScrapProductEntity UpdateSProductEntity,
            ResponProcedureEntity UpdateRProcedureEntity,
            List<ScrapResponsibleEntity> UpdateSResponsibleList, List<ScrapResponsibleEntity> YSResponsibleList)
        {
            return this.Invoker.Invoke<int>(p => p.UpdateScrapProduct(UpdateSProductEntity, UpdateRProcedureEntity, UpdateSResponsibleList.ToArray(), YSResponsibleList.ToArray()));
        }

        /// <summary>
        /// 根据页面条件获取废弃产品一览
        /// </summary>
        /// <param name="selectProEntity">废弃产品</param>
        /// <returns>DataSet</returns>
        public DataSet GetScrapProduct(ScrapProductEntity selectProEntity)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetScrapProduct(selectProEntity));
        }

        /// <summary>
        /// 根据责任工序ID获取责任人列表
        /// </summary>
        /// <param name="ResponProcedureId">责任工序ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetScrapResponsibleByResponProcedureID(int ResponProcedureId)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetScrapResponsibleByResponProcedureID(ResponProcedureId));
        }

        /// <summary>
        /// 根据废弃产品ID获取责任人列表
        /// </summary>
        /// <param name="SPId">废弃产品ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetScrapResponsibleBySPId(int SPId)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetScrapResponsibleBySPId(SPId));
        }

        /// <summary>
        /// 根据废弃产品ID获取责任工序
        /// </summary>
        /// <param name="SPId">废弃产品ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetResponProcedureBySPId(int SPId)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetResponProcedureBySPId(SPId));
        }

        /// <summary>
        /// 验证废弃产品唯一性
        /// </summary>
        /// <param name="BarCode">产品条码</param>
        /// <returns>int</returns>
        public string ScrapProductChack(string BarCode)
        {
            return this.Invoker.Invoke<string>(p => p.ScrapProductChack(BarCode));
        }

        /// <summary>
        /// 审核报损产品信息
        /// </summary>
        /// <param name="spEntity">被审核的产品实体</param>
        /// <returns>int</returns>
        public int AuditScrapProduct(ScrapProductEntity spEntity)
        {
            return this.Invoker.Invoke<int>(p => p.AuditScrapProduct(spEntity));
        }

        #endregion

        #region 生产管理：计件

        /// <summary>
        /// 根据条码获得在产信息
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <returns>DataSet</returns>
        public DataSet GetInProductionByBarcode(string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetInProductionByBarcode(barcode));
        }

        /// <summary>
        /// 使用存储过程PRO_PM_SearchProductionData获取生产工序计件数据
        /// </summary>
        /// <param name="searchEntity">生产数据实体类</param>
        /// <returns>DataTable</returns>
        public DataTable SearchProductionData(SearchProductionDataEntity searchEntity)
        {
            return this.Invoker.Invoke<DataTable>(p => p.SearchProductionData(searchEntity));
        }

        /// <summary>
        /// 使用存储过程PRO_PM_GetProductionData获取生产工序计件数据
        /// </summary>
        /// <param name="searchEntity">生产数据实体类</param>
        /// <returns>DataTable</returns>
        public DataTable GetProductionData(SearchProductionDataEntity searchEntity)
        {
            return this.Invoker.Invoke<DataTable>(p => p.GetProductionData(searchEntity));
        }

        /// <summary>
        /// 使用存储过程PRO_PM_GetProductionDataPDA获取生产工序计件数据
        /// </summary>
        /// <param name="searchEntity">生产数据实体类</param>
        /// <returns>DataTable</returns>
        public DataTable GetProductionDataPDA(SearchProductionDataEntity searchEntity)
        {
            return this.Invoker.Invoke<DataTable>(p => p.GetProductionDataPDA(searchEntity));
        }

        /// <summary>
        /// 获取生产工序实体
        /// </summary>
        /// <param name="procedureID">工序ID</param>
        /// <returns>ProcedureEntity实体类</returns>
        public ProcedureEntity GetProcedureDataEntityByID(int procedureID)
        {
            return this.Invoker.Invoke<ProcedureEntity>(p => p.GetProcedureDataEntityByID(procedureID));
        }

        /// <summary>
        /// 判断操作人员是否具有工序权限
        /// </summary>
        /// <param name="procedureID">工序ID</param>
        /// <param name="userID">工号ID</param>
        /// <returns>DataSet</returns>
        public DataSet DecideUserInProcedure(int procedureID, int userID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.DecideUserInProcedure(procedureID, userID));
        }

        /// <summary>
        /// 检验条码
        /// </summary>
        /// <param name="procedureID">工序ID</param>
        /// <param name="barcode">产品条码</param>
        /// <returns>DataSet</returns>
        public DataSet CheckBarcode(int procedureID, string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.CheckBarcode(procedureID, barcode));
        }

        /// <summary>
        ///  检验此用户是否允许生产工序
        /// </summary>
        /// <param name="procedureID">工序ID</param>
        /// <param name="UserID">工号ID</param>
        /// <returns>CheckProcedureUserResult实体类</returns>
        public CheckProcedureUserResult CheckProcedureUser(int procedureID, string UserCode)
        {
            return this.Invoker.Invoke<CheckProcedureUserResult>(p => p.CheckProcedureUser(procedureID, UserCode));
        }

        /// <summary>
        /// 保存生产数据
        /// </summary>
        /// <param name="productionData">生产数据对象</param>
        /// <returns>string</returns>
        public string SaveProductionData(ProductionDataEntity productionData)
        {
            return this.Invoker.Invoke<string>(p => p.SaveProductionData(productionData));
        }

        /// <summary>
        /// 添加生产计件
        /// </summary>
        /// <param name="procedureID">工序ID</param>
        /// <param name="barcodeTable">条码信息</param>
        /// <returns>DataTable   null:添加成功 不为空：错误消息</returns>
        /// <remarks>
        /// 陈冰              2014.09.18              新建
        /// </remarks>
        public DataTable AddWorkPiece(int procedureID, DataTable barcodeTable)
        {
            return this.Invoker.Invoke<DataTable>(p => p.AddWorkPiece(procedureID, barcodeTable));
        }

        /// <summary>
        /// 校验窑车是否可用
        /// </summary>
        /// <param name="pProcedureId">工序ID</param>
        /// <param name="kilnCarCode">窑车号</param>
        /// <param name="pModelType">类别</param>
        /// <returns>CheckKilnCarResultEntity实体类</returns>
        /// <remarks>
        /// 陈冰              2014.09.26              新建
        /// </remarks>
        public CheckKilnCarResultEntity CheckKilnCar(int pProcedureId, string kilnCarCode, int pModelType)
        {
            return this.Invoker.Invoke<CheckKilnCarResultEntity>(p => p.CheckKilnCar(pProcedureId, kilnCarCode, pModelType));
        }

        #endregion

        #region 温湿计信息
        /// <summary>
        /// 添加温湿计信息
        /// </summary>
        /// <param name="crEntity">温湿计信息实体</param>
        /// <returns>影响行/结果</returns>
        public int AddCelsiusRecord(CelsiusRecordEntity crEntity)
        {
            return this.Invoker.Invoke<int>(p => p.AddCelsiusRecord(crEntity));
        }

        /// <summary>
        /// 修改温湿计信息
        /// </summary>
        /// <param name="crEntity">温湿计信息实体</param>
        /// <returns>影响行/结果</returns>
        public int UpdateCelsiusRecord(CelsiusRecordEntity crEntity)
        {
            return this.Invoker.Invoke<int>(p => p.UpdateCelsiusRecord(crEntity));
        }

        /// <summary>
        /// 获得温湿计信息
        /// </summary>
        /// <param name="celsiusRecordEntity">温湿计信息实体</param>
        /// <returns>数据源Dataset</returns>
        /// <remarks>
        /// 庄天威              2014.09.10              新建
        /// </remarks>
        public DataSet GetCelsiusRecord(CelsiusRecordEntity celsiusRecordEntity)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetCelsiusRecord(celsiusRecordEntity));
        }

        /// <summary>
        /// 获得温湿计信息(图表)
        /// </summary>
        /// <param name="celsiusRecordEntity">温湿计信息实体</param>
        /// <returns>数据源Dataset</returns>
        /// <remarks>
        /// 庄天威              2014.09.10              新建
        /// </remarks>
        public DataSet GetCelsiusRecordView(CelsiusRecordEntity celsiusRecordEntity)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetCelsiusRecordView(celsiusRecordEntity));
        }

        /// <summary>
        /// 批量操作温湿计信息
        /// </summary>
        /// <param name="RecordTime">记录时间</param>
        /// <param name="dtCelsius">信息数据集</param>
        /// <returns>影响行数</returns>
        public int EditCelsiusRecord(DateTime RecordTime, DataTable dtCelsius)
        {
            return this.Invoker.Invoke<int>(p => p.EditCelsiusRecord(RecordTime, dtCelsius));
        }

        /// <summary>
        /// 删除温湿计信息
        /// </summary>
        /// <param name="recordID">记录ID</param>
        /// <returns>影响行数</returns>
        public int DeleteCelsiusRecord(int recordID)
        {
            return this.Invoker.Invoke<int>(p => p.DeleteCelsiusRecord(recordID));
        }
        #endregion

        #region 获取注浆次数（By工号）
        /// <summary>
        /// 获取注浆次数（By工号）
        /// </summary>
        /// <param name="gcEntity">查询条件实体</param>
        /// <returns>返回信息数据集</returns>
        public DataSet GetGroutingCountByUser(GroutingCountByUserEntity gcEntity)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetGroutingCountByUser(gcEntity));
        }
        #endregion

        /// <summary>
        /// 根据工序条码获得生产数据
        /// </summary>
        /// <param name="procedureID">工序ID</param>
        /// <param name="barcode">产品条码</param>
        /// <returns>DataSet</returns>
        public DataSet GetProductionByBarcode(int procedureID, string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetProductionByBarcode(procedureID, barcode));
        }

        /// <summary>
        /// 获取生产返工工序
        /// </summary>
        /// <param name="procedureID">工序ID</param>
        /// <param name="barcode">产品条码</param>
        /// <returns>DataSet</returns>
        public DataSet GetReworkProcedureByBarcode(int procedureID, string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetReworkProcedureByBarcode(procedureID, barcode));
        }

        /// <summary>
        /// 由工序获取产缺陷列表
        /// </summary>
        /// <param name="procedureID">工序ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetDefectByProcedure(int procedureID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetDefectByProcedure(procedureID));
        }

        /// <summary>
        /// 根据产品ID查出缺陷位置
        /// </summary>
        /// <param name="goodsID">产品ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetDefectLocaionByGoodsID(int goodsID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetDefectLocaionByGoodsID(goodsID));
        }

        /// <summary>
        /// 通过条码查出责任工序
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <param name="defectid">缺陷ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetDutyProcedureByBarCode(string barcode, int defectid)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetDutyProcedureByBarCode(barcode, defectid));
        }


        /// <summary>
        /// <summary>
        /// 责任工序查出工号根据生产数据ID
        /// </summary>
        /// <param name="ProductionDataID"></param>
        /// <returns>DataSet</returns>
        public DataSet GetDutyProcedureCodeByProductionDataID(int ProductionDataID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetDutyProcedureCodeByProductionDataID(ProductionDataID));
        }

        /// <summary>
        /// 通过条码与工序查出责任工号
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <param name="dutyProcedureID">责任工序</param>
        /// <returns>DataSet</returns>
        public DataSet GetDutyProcedureCodeByBarCode(string barcode, int dutyProcedureID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetDutyProcedureCodeByBarCode(barcode, dutyProcedureID));
        }

        /// <summary>
        /// 根据所选工序默认查出工种信息
        /// </summary>
        /// <param name="userID">工号ID</param>
        /// <param name="productionDataID">生产数据ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetDutyJobsCodeByUser(int userID, int productionDataID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetDutyJobsCodeByUser(userID, productionDataID));
        }

        /// <summary>
        /// 根据所选生产数据ID，用户ID及工种选出责任员工
        /// </summary>
        /// <param name="productionDataID">生产数据ID</param>
        /// <param name="userID">用户ID</param>
        /// <param name="jobs">工种ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetDutyStaffByUserIDAndJobs(int productionDataID, int userID, int jobs)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetDutyStaffByUserIDAndJobs(productionDataID, userID, jobs));
        }

        /// <summary>
        /// 根据传入的实体获取进度考核奖惩信息
        /// </summary>
        /// <param name="searchAdminRAPEntity">查询实体</param>
        /// <returns>DataSet进度考核奖惩信息表</returns>
        public DataSet SearcStaffAdminRAPInfo(SearchProgressRAPEntity searchProgressRAPEntity)
        {
            return this.Invoker.Invoke<DataSet>(p => p.SearcStaffAdminRAPInfo(searchProgressRAPEntity));
        }

        #region 进度考核奖惩

        /// <summary>
        /// 根据传入的实体保存 进度考核奖惩记录
        /// </summary>
        /// <param name="pAdminRAPEntity">进度考核奖惩实体</param>
        /// <param name="pStatus">新增还是编辑枚举</param>
        /// <returns>PMResultEntity操作结果状态信息</returns>
        public PMResultEntity SaveStaffProgressRAPInfo(PMProgressRAPEntity pProgressRAPEntity, WCFConstant.FormMode editStatus)
        {
            return this.Invoker.Invoke<PMResultEntity>(p => p.SaveStaffProgressRAPInfo(pProgressRAPEntity, editStatus));
        }

        /// <summary>
        /// 进度考核奖惩审批
        /// </summary>
        /// <param name="pAdminRAPEntity">进度考核奖惩实体</param>
        /// <param name="pState">审批状态 True 通过  False 不通过</param>
        /// <returns>PMResultEntity操作结果状态信息</returns>
        public PMResultEntity SaveStaffProgressRAPApprovalInfo(PMProgressRAPEntity pProgressRAPEntity, bool pState)
        {
            return this.Invoker.Invoke<PMResultEntity>(p => p.SaveStaffProgressRAPApprovalInfo(pProgressRAPEntity, pState));
        }

        /// <summary>
        /// 设置进度考核奖惩停用
        /// </summary>
        /// <param name="pRAPID">进度考核奖惩编号</param>
        /// <returns>PMResultEntity操作结果状态信息</returns>
        public PMResultEntity SetStaffProgressRAPValueFlag(int pRAPID)
        {
            return this.Invoker.Invoke<PMResultEntity>(p => p.SetStaffProgressRAPValueFlag(pRAPID));
        }

        /// <summary>
        /// 保存条码信息
        /// </summary>
        /// <param name="procedureID">工序ID</param>
        /// <param name="productionDataEntitys">生产数据集</param>
        /// <returns>string</returns>
        public string AddCheckBarcode(int procedureID, ProductionDataEntity[] productionDataEntitys)
        {
            return this.Invoker.Invoke<string>(p => p.AddCheckBarcode(procedureID, productionDataEntitys));
        }

        #endregion

        /// <summary>
        /// 根据条码获取窑炉窑车信息
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <returns>DataSet</returns>
        public DataSet GetKilnCarByBarCode(string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetKilnCarByBarCode(barcode));
        }

        /// <summary>
        /// 根据生产数据ID获取对应的缺陷信息
        /// </summary>
        /// <param name="ProductionDataID">生产数据ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetProductionDefectByProductionDataID(int ProductionDataID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetProductionDefectByProductionDataID(ProductionDataID));
        }

        /// <summary>
        /// 获取重烧生产返工工序
        /// </summary>
        /// <param name="procedureID">工序ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetReworkProcedureByProcedureID(int procedureID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetReworkProcedureByProcedureID(procedureID));
        }

        #region  生产数据查询

        /// <summary>
        /// 查询在产产品数据
        /// </summary>
        /// <param name="searchInProductionEntity">在产产品数据实体</param>
        /// <returns>DataSet在产产品数据信息表</returns>>
        public DataSet GetInProductionData(SearchInProductionEntity searchInProductionEntity)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetInProductionData(searchInProductionEntity));
        }

        /// <summary>
        /// 查询成品数据
        /// </summary>
        /// <param name="searchInProductionEntity">产成品数据实体</param>
        /// <returns>DataSet产成品数据信息表</returns>
        public DataSet GetFinishedProductionData(SearchFinishedProductEntity searchFinishedProductionEntity)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetFinishedProductionData(searchFinishedProductionEntity));
        }

        /// <summary>
        /// 查询半检数据一览
        /// </summary>
        /// <param name="SearchSemiTestDetailEntity">查询半检数据明细实体类</param>
        /// <returns>DataSet</returns>
        public DataSet GetSearchSemiTestListModule(SemiTestDetailEntity semiTestDetailEntity)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetSearchSemiTestListModule(semiTestDetailEntity));
        }

        #endregion

        #region 撤销装车

        /// <summary>
        /// 校验条码是否可以下车
        /// </summary>
        /// <param name="procedureID">当前工序</param>
        /// <param name="barcode">产品条码</param>
        /// <returns>CheckCancelLoadCar</returns>
        public CheckCancelLoadCar CheckCancelLoadCar(int procedureID, string barcode)
        {
            return this.Invoker.Invoke<CheckCancelLoadCar>(p => p.CheckCancelLoadCar(procedureID, barcode));
        }

        /// <summary>
        /// 添加撤销装车
        /// </summary>
        /// <param name="procedureID"><工序ID/param>
        /// <param name="barcode">产品条码</param>
        /// <returns>string</returns>
        public string AddCancelLoadCar(int procedureID, string barcode)
        {
            return this.Invoker.Invoke<string>(p => p.AddCancelLoadCar(procedureID, barcode));
        }

        #endregion

        /// <summary>
        /// 根据所选生产数据ID,显示成检数据信息
        /// </summary>
        /// <param name="productionDataID">生产数据ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetProductionDataByID(int productionDataID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetProductionDataByID(productionDataID));
        }

        /// <summary>
        /// 获取产品完成工序的ID
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <returns>int</returns>
        public int GetCompleteProcedureID(string barcode)
        {
            return this.Invoker.Invoke<int>(p => p.GetCompleteProcedureID(barcode));
        }

        /// <summary>
        /// 编辑后删除生产数据
        /// </summary>
        /// <param name="productionDataID">生产数据ID</param>
        /// <returns>int</returns>
        public int DeleteProductionDataByID(int productionDataID)
        {
            return this.Invoker.Invoke<int>(p => p.DeleteProductionDataByID(productionDataID));
        }

        /// <summary>
        /// 由产品条码获取注浆信息
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <returns>DataSet</returns>
        public DataSet GetGroutingProducttByBarCode(string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetGroutingProducttByBarCode(barcode));
        }

        /// <summary>
        /// 根据所选工号对应的工种，查出缺陷责任员工
        /// </summary>
        /// <param name="jobs">工种ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetDutyStaffByUserID(int jobs)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetDutyStaffByUserID(jobs));
        }

        /// <summary>
        /// 根据所选工号，查出漏检责任员工
        /// </summary>
        /// <param name="userid">工号</param>
        /// <returns>DataSet</returns>
        public DataSet GetMissedStaffByUserID(int userid)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetMissedStaffByUserID(userid));
        }

        /// <summary>
        /// 保存半检测信息
        /// </summary>
        /// <param name="semiTestEntitys">半检实体类</param>
        /// <returns>string</returns>
        public string AddSemiTest(SemiTestEntity[] semiTestEntitys)
        {
            return this.Invoker.Invoke<string>(p => p.AddSemiTest(semiTestEntitys));
        }

        /// <summary>
        /// 获取半检相应的数据
        /// </summary>
        /// <param name="semiTestID">半检ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetSemiTestByID(int semiTestID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetSemiTestByID(semiTestID));
        }

        /// <summary>
        /// 编辑后禁用半检数据
        /// </summary>
        /// <param name="semiTestID">半检数据ID</param>
        /// <returns>int</returns>
        public int DeleteSemiTestDataByID(int semiTestID)
        {
            return this.Invoker.Invoke<int>(p => p.DeleteSemiTestDataByID(semiTestID));
        }

        /// <summary>
        /// 验证时间戳
        /// </summary>
        /// <param name="semiTestID">半检ID</param>
        /// <param name="opTimeStamp">时间戳</param>
        /// <returns>int</returns>
        public int ValidateOPTimeStamp(int semiTestID, DateTime opTimeStamp)
        {
            return this.Invoker.Invoke<int>(p => p.ValidateOPTimeStamp(semiTestID, opTimeStamp));
        }

        /// <summary>
        /// 更新审核状态
        /// </summary>
        /// <param name="semiTestID">半检ID</param>
        /// <param name="auditStatus">审核状态</param>
        /// <returns>int</returns>
        public int UpdateSemiTestByID(int semiTestID, int auditStatus)
        {
            return this.Invoker.Invoke<int>(p => p.UpdateSemiTestByID(semiTestID, auditStatus));
        }

        /// <summary>
        /// 获取审批半检数据结果集
        /// </summary>
        /// <param name="semiTestEntity">半检实体类</param>
        /// <returns>DataSet</returns>
        public DataSet SearchSemiTestList(SemiTestEntity semiTestEntity)
        {
            return this.Invoker.Invoke<DataSet>(p => p.SearchSemiTestList(semiTestEntity));
        }

        /// <summary>
        /// 获取半检数据详细数据源
        /// </summary>
        /// <param name="semitestID">半检ID</param>
        /// <returns>DataSet</returns>
        public DataSet SearchSemiTestInfo(int semitestID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.SearchSemiTestInfo(semitestID));
        }

        /// <summary>
        /// 根据所选生产数据ID，用户ID及工种选出责任员工
        /// </summary>
        /// <param name="userID">用户ID</param>
        /// <param name="jobs">工种ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetDutyStaffByUserJobsID(int jobs, int userID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetDutyStaffByUserJobsID(jobs, userID));
        }

        /// <summary>
        /// 获取半检数据详细数据源(一览)
        /// </summary>
        /// <param name="semitestDetailID">半检明细ID</param>
        /// <returns>DataSet</returns>
        public DataSet SearchSemiTestDetailInfo(int semitestDetailID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.SearchSemiTestDetailInfo(semitestDetailID));
        }

        /// <summary>
        /// 获取次品产品条码允许编辑
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <returns>Datase</returns>
        public DataSet GetSubstandardInfo(string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetSubstandardInfo(barcode));
        }

        /// <summary>
        /// 获取产品条码是否重烧
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <returns>Datase</returns>
        public DataSet GetReFine(string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetReFine(barcode));
        }

        /// <summary>
        /// 根据条码及工序判断是否漏扫
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <param name="produceid">校验工序ID</param>
        public int AddBarCodeMissing(string barcode, int produceid)
        {
            return this.Invoker.Invoke<int>(p => p.AddBarCodeMissing(barcode, produceid));
        }

        /// <summary>
        /// 检验干补条码
        /// </summary>
        /// <param name="procedureID">工序ID</param>
        /// <param name="barcode">产品条码</param>
        /// <returns>DataSet</returns>
        public DataSet CheckDryRepairBarcode(int procedureID, string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.CheckDryRepairBarcode(procedureID, barcode));
        }

        /// <summary>
        /// 获取干补标识
        /// </summary>
        /// <param name="barcode">产品条码</param>ram>
        /// <returns>int</returns>
        public int GetSpecialRepairflagByBarcode(string barcode)
        {
            return this.Invoker.Invoke<int>(p => p.GetSpecialRepairflagByBarcode(barcode));
        }

        /// <summary>
        ///  获取窑车对应产品列表
        /// </summary>
        /// <param name="KilnCarID">窑车ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetKilnCarGoodsByKilnCarID(int KilnCarID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetKilnCarGoodsByKilnCarID(KilnCarID));
        }

        /// <summary>
        /// 获取未在生产线上报损的注浆信息
        /// <param name="barcode">产品条码</param>
        /// </summary>
        /// <returns>DataSet</returns>
        public DataSet GetBarCodeInGroutingDailyDetail(string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetBarCodeInGroutingDailyDetail(barcode));
        }

        /// <summary>
        /// 获取编辑的生产数据ID与列表所选生产数据ID做比较
        /// <param name="barcode">产品条码</param>
        /// </summary>
        /// <returns>DataSet</returns>
        public int GetCompleteProductionDataID(string barcode)
        {
            return this.Invoker.Invoke<int>(p => p.GetCompleteProductionDataID(barcode));
        }

        /// <summary>
        /// 获取在产产品的信息标识列表
        /// <param name="barcode">产品条码</param>
        /// </summary>
        /// <returns>DataSet</returns>
        public DataSet GetInProductionDataList(string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetInProductionDataList(barcode));
        }

        /// <summary>
        /// 成检时获取此条码是否报损 
        /// <param name="barcode">产品条码</param>
        /// </summary>
        /// <returns>int</returns>
        public int CheckScrapProduct(string barcode)
        {
            return this.Invoker.Invoke<int>(p => p.CheckScrapProduct(barcode));
        }

        /// <summary>
        ///成检时获取条码的产品信息（成检(正品)--报损-->干补-->成检）
        /// <param name="barcode">产品条码</param>
        /// </summary>
        /// <returns>DataSet</returns>
        public DataSet GetGoodsInfoBybarcode(string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetGoodsInfoBybarcode(barcode));
        }

        /// <summary>
        /// 更新漏扫的成型工号
        /// </summary>
        /// <param name="groutingUserCode">成型工号</param>
        /// <param name="missingID">漏扫ID</param>
        /// <returns>int</returns>
        public int UpdateGroutingUserCodeByMissingID(string groutingUserCode, int missingID)
        {
            return this.Invoker.Invoke<int>(p => p.UpdateGroutingUserCodeByMissingID(groutingUserCode, missingID));
        }

        /// <summary>
        /// 在入窑工序检验窑车号是否存在
        /// </summary>
        /// <param name="kilncarcode">窑车编码</param>
        /// <param name="procedureid">工序ID</param>
        /// <returns></returns>
        public int CheckKilnCarByIntoCar(string kilncarcode, int procedureid)
        {
            return this.Invoker.Invoke<int>(p => p.CheckKilnCarByIntoCar(kilncarcode, procedureid));
        }

        /// <summary>
        /// 生成盘点明细
        /// </summary>
        /// <param name="ProcedureIDS">工序ID集</param>
        /// <returns></returns>
        public DataSet GetInCheckedDetail(string ProcedureIDS)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetInCheckedDetail(ProcedureIDS));
        }

        public int SaveInChecked(InProductionEntity[] inProductionEntity, string remarks)
        {
            return this.Invoker.Invoke<int>(p => p.SaveInChecked(inProductionEntity, remarks));
        }

        /// <summary>
        /// 获取盘点单列表
        /// </summary>
        /// <returns></returns>
        public DataSet GetInCheckedList()
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetInCheckedList());
        }

        /// <summary>
        /// 获取盘点单列表
        /// </summary>
        /// <returns></returns>
        public DataSet GetInCheckedUserList(int InCheckedID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetInCheckedUserList(InCheckedID));
        }

        /// <summary>
        /// 更新盘点单
        /// </summary>
        /// <param name="InCheckedID">盘点单号</param>
        /// <param name="BarCode">产品条码</param>
        /// <returns></returns>
        public int UpdateInChecked(int InCheckedID, string BarCode)
        {
            return this.Invoker.Invoke<int>(p => p.UpdateInChecked(InCheckedID, BarCode));
        }

        /// <summary>
        /// 停用盘点单
        /// </summary>
        /// <param name="InCheckedID">盘点单号</param>
        public int DisableInChecked(int inCheckedID)
        {
            return this.Invoker.Invoke<int>(p => p.DisableInChecked(inCheckedID));
        }

        /// <summary>
        /// 获取主表盘点信息
        /// </summary>
        /// <param name="entity">盘点类</param>
        /// <returns></returns>
        public DataSet GetAllInChecked(InCheckedEntity entity)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetAllInChecked(entity));
        }

        /// <summary>
        ///  获取盘点单名细信息
        /// </summary>
        /// <param name="inCheckedID">盘点单ID</param>
        /// <returns></returns>
        public DataSet GetAllInCheckedDetail(int inCheckedID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetAllInCheckedDetail(inCheckedID));
        }

        /// <summary>
        /// <summary>
        /// 报损工序查出工号根据生产数据ID
        /// </summary>
        /// <param name="ProductionDataID"></param>
        /// <returns>DataSet</returns>
        public DataSet GetScrapProductUserCodeByProductionDataID(int ProductionDataID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetScrapProductUserCodeByProductionDataID(ProductionDataID));
        }

        /// <summary>
        /// 在入窑工序检验窑车号是否存在
        /// </summary>
        /// <param name="kilncarcode">窑车编码</param>
        /// <param name="procedureid">工序ID</param>
        /// <returns></returns>
        public int CheckKilnCarByIntoCar2(string kilncarcode, int procedureid)
        {
            return this.Invoker.Invoke<int>(p => p.CheckKilnCarByIntoCar2(kilncarcode, procedureid));
        }

        /// <summary>
        /// 撤销包装
        /// </summary>
        /// <param name="barcode"></param>
        /// <returns></returns>
        public ServiceResultEntity AddChancelFinishedproduct(string barcode)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.AddChancelFinishedproduct(barcode));
        }

        /// <summary>
        /// 撤销报损
        /// </summary>
        /// <param name="barcode"></param>
        /// <returns></returns>
        public ServiceResultEntity AddCancelScrapProduction(string barcode)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.AddCancelScrapProduction(barcode));
        }

        /// <summary>
        /// 获取撤销条码信息
        /// </summary>
        /// <param name="barcode"></param>
        /// <returns></returns>
        public DataSet GetGroutingInfoBybarcode(string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetGroutingInfoBybarcode(barcode));
        }

        /// <summary>
        /// 获取撤销条码信息
        /// </summary>
        /// <param name="barcode"></param>
        /// <returns></returns>
        public DataSet GetFinishedProductGroutingInfoBybarcode(string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetFinishedProductGroutingInfoBybarcode(barcode));
        }

        /// <summary>
        /// 公坯设定
        /// </summary>
        /// <param name="barcode"></param>
        /// <returns></returns>
        public int AddPublicBodyProduct(string barcode)
        {
            return this.Invoker.Invoke<int>(p => p.AddPublicBodyProduct(barcode));
        }

        /// <summary>
        /// 交坯检验条码
        /// </summary>
        /// <param name="procedureID">工序ID</param>
        /// <param name="barcode">产品条码</param>
        /// <returns>DataSet</returns>
        public DataSet CheckBarcodeDeliverMud(int procedureID, string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.CheckBarcodeDeliverMud(procedureID, barcode));
        }

        /// <summary>
        /// 获取清除在产残留数据一览
        /// </summary>
        /// <param name="se"></param>
        /// <returns></returns>
        public ServiceResultEntity GetPM2108Data(RPT010401_SE se)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.GetPM2108Data(se));
        }

        /// <summary>
        /// 清除在产残留数据（清除选择）
        /// </summary>
        /// <param name="barcodes">产品条码集</param>
        /// <returns></returns>
        public int SaveClearInproduction(string barcodes)
        {
            return this.Invoker.Invoke<int>(p => p.SaveClearInproduction(barcodes));
        }

        /// <summary>
        /// 清除在产残留数据（批量清除选择）
        /// </summary>
        /// <<param name="se">查询条件</param>
        /// <returns></returns>
        public int SaveClearAllInproduction(RPT010401_SE se)
        {
            return this.Invoker.Invoke<int>(p => p.SaveClearAllInproduction(se));
        }

        /// <summary>
        /// 获取清除在产回收站残留数据一览
        /// </summary>
        /// <param name="se"></param>
        /// <returns></returns>
        public ServiceResultEntity GetPM2110Data(FPM2110_SE se)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.GetPM2110Data(se));
        }


        /// <summary>
        /// 清除在产回收站残留数据（清除选择）
        /// </summary>
        /// <param name="barcodes">产品条码集</param>
        /// <returns></returns>
        public int SaveClearInproductionTrash(string barcodes)
        {
            return this.Invoker.Invoke<int>(p => p.SaveClearInproductionTrash(barcodes));
        }

        /// <summary>
        /// 清除在产回收站残留数据（批量清除选择）
        /// </summary>
        /// <<param name="se">查询条件</param>
        /// <returns></returns>
        public int SaveClearAllInproductionTrash(FPM2110_SE se)
        {
            return this.Invoker.Invoke<int>(p => p.SaveClearAllInproductionTrash(se));
        }

        /// <summary>
        /// 获取清除在产临时表残留数据一览
        /// </summary>
        /// <param name="se"></param>
        /// <returns></returns>
        public ServiceResultEntity GetPM2112Data(FPM2112_SE se)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.GetPM2112Data(se));
        }

        /// <summary>
        /// 清除在产临时表残留数据（清除选择）
        /// </summary>
        /// <param name="barcodes">产品条码集</param>
        /// <returns></returns>
        public int SaveClearInproductionTmp(string barcodes)
        {
            return this.Invoker.Invoke<int>(p => p.SaveClearInproductionTmp(barcodes));
        }

        /// <summary>
        /// 清除在产临时表残留数据（批量清除选择）
        /// </summary>
        /// <<param name="se">查询条件</param>
        /// <returns></returns>
        public int SaveClearAllInproductionTmp(FPM2112_SE se)
        {
            return this.Invoker.Invoke<int>(p => p.SaveClearAllInproductionTmp(se));
        }

        /// <summary>
        /// 恢复数据
        /// </summary>
        /// <<param name="barcode">产品条码</param>
        /// <returns></returns>
        public int ResetBarCode(string barcode)
        {
            return this.Invoker.Invoke<int>(p => p.ResetBarCode(barcode));
        }

        /// <summary>
        /// 批量恢复数据
        /// </summary>
        /// <param name="barcodes">产品条码集</param>
        /// <returns></returns>
        public int ResetSelectedBarCode(string barcodes)
        {
            return this.Invoker.Invoke<int>(p => p.ResetSelectedBarCode(barcodes));
        }

        public ServiceResultEntity AddChancelBarCode(string barcode)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.AddChancelBarCode(barcode));
        }

        /// <summary>
        /// 获取条码在产时间戳
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <returns>DataSet</returns>
        public DataSet GetCompleteProcedureIDPDA(string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetCompleteProcedureIDPDA(barcode));
        }

        public ServiceResultEntity AddChancelDeliverMudBarCode(string barcode)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.AddChancelDeliverMudBarCode(barcode));
        }

        public int SaveClearInChecked(int inCheckedID, string barcodes)
        {
            return this.Invoker.Invoke<int>(p => p.SaveClearInChecked(inCheckedID, barcodes));
        }

        public int SaveClearInCheckedAll(int inCheckedID, string procedureIDs, string goodsCodes, DateTime? startDateTime, DateTime? endDateTime)
        {
            return this.Invoker.Invoke<int>(p => p.SaveClearInCheckedAll(inCheckedID, procedureIDs, goodsCodes, startDateTime, endDateTime));
        }

        public int GetLogoID(int ProcedureID)
        {
            return this.Invoker.Invoke<int>(p => p.GetLogoID(ProcedureID));
        }

        public int SaveBarCodeLogo(string barcode, int logoid)
        {
            return this.Invoker.Invoke<int>(p => p.SaveBarCodeLogo(barcode, logoid));
        }

        public DataSet GetBarCodeLogoID(string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetBarCodeLogoID(barcode));
        }

        /// <summary>
        /// 半检时,入窑前检验获取此条码是否报损为废品
        /// <param name="barcode">产品条码</param>
        /// </summary>
        /// <returns>int</returns>
        public int CheckWasteScrapProduct(string barcode)
        {
            return this.Invoker.Invoke<int>(p => p.CheckWasteScrapProduct(barcode));
        }

        /// <summary>
        /// 获取半成品检验列表
        /// <param name="entity">实体类</param>
        /// </summary>
        /// <returns>DataSet</returns>
        public DataSet GetSemiCheck(SemiCheckEntity entity)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetSemiCheck(entity));
        }

        /// <summary>
        /// 获取半成品检验缺陷列表
        /// <param name="semiCheckID">半成品检验ID</param>
        /// </summary>
        /// <returns>DataSet</returns>
        public DataSet GetSemiCheckDefect(int semiCheckID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetSemiCheckDefect(semiCheckID));
        }

        /// <summary>
        /// 获取登陆帐户有无半检状态权限
        /// </summary>
        /// <param name="usercode">工号编码</param>
        /// <returns></returns>
        public int GetSemiCheckStatusFuntion()
        {
            return this.Invoker.Invoke<int>(p => p.GetSemiCheckStatusFuntion());
        }


        /// <summary>
        ///半检校验条码
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <returns></returns>
        public ServiceResultEntity SemiCheckBarcode(string barcode)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.SemiCheckBarcode(barcode));
        }

        /// <summary>
        /// 根据半成品检验数据ID,显示半成品数据信息
        /// </summary>
        /// <param name="semiCheckID">半成品数据ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetSemiCheckByID(int semiCheckID)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetSemiCheckByID(semiCheckID));
        }

        /// <summary>
        /// 根据条码获取经过的工序,用于绑定返工工序
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <returns>DataSet</returns>
        public DataSet GetSemiCheckPassProcedure(string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetSemiCheckPassProcedure(barcode));
        }


        /// <summary>
        /// 根据所选工号，查出缺陷责任员工
        /// </summary>
        /// <param name="userid">用户ID</param>
        /// <returns>DataSet</returns>
        public DataSet GetSemiCheckDefectStaffByUserID(int userid)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetSemiCheckDefectStaffByUserID(userid));
        }

        /// <summary>
        /// 保存半检登记
        /// </summary>
        /// <param name="entity">半检实体类</param>
        /// <param name="sUserInfo">用户基本信息</param>
        /// <returns>ServiceResultEntity</returns>
        /// <remarks>
        /// 王鑫              2016.06.27              新建
        /// </remarks>
        public ServiceResultEntity AddSemiCheck(SemiCheckEntity[] entityobj)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.AddSemiCheck(entityobj));
        }

        /// <summary>
        /// 复检校验条码
        /// </summary>
        /// <param name="barcode">条码</param>
        /// <returns></returns>
        public ServiceResultEntity ReSemiCheckBarcode(string barcode)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.ReSemiCheckBarcode(barcode));
        }

        /// <summary>
        /// 撤销复检验条码
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <returns>DataSet</returns>
        public ServiceResultEntity CancelSemiCheckBarcode(string barcode)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.CancelSemiCheckBarcode(barcode));
        }

        /// <summary>
        ///  校验条码是否允许撤销，如果不允许提示错误消息
        /// </summary>
        /// <param name="orgTime">原时间</param>
        /// <param name="days">允许撤销天数</param>
        /// <param name="settingCode">设置code,用于返回不同错误消息</param>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ServiceResultEntity BarcodeAllowCancel(DateTime orgTime, int days, string settingCode)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.BarcodeAllowCancel(orgTime, days, settingCode));
        }

        #region 生产订单

        /// <summary>
        /// 保存订单
        /// </summary>
        /// <param name="order"></param>
        /// <returns></returns>
        public ServiceResultEntity SaveOrder(OrderEntity order)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.SaveOrder(order));
        }

        /// <summary>
        /// 启用、停用订单标识
        /// </summary>
        /// <param name="order"></param>
        /// <returns></returns>
        public ServiceResultEntity ChangeOrderFlag(OrderEntity order)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.ChangeOrderFlag(order));
        }

        /// <summary>
        /// 获取生产订单一览列表
        /// </summary>
        /// <param name="order"></param>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public DataSet GetOrderList(OrderEntity order)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetOrderList(order));
        }

        /// <summary>
        /// 获取产成品交接
        /// </summary>
        /// <param name="entity"></param>
        /// <returns></returns>
        public DataSet GetFinishedHandover(SearchFinishedProductEntity entity)
        {
            return this.Invoker.Invoke<DataSet>(p => p.GetFinishedHandover(entity));
        }

        public ServiceResultEntity FinishedHandoverBarcode(string barcode)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.FinishedHandoverBarcode(barcode));
        }

        public ServiceResultEntity SaveFinishedHandover(int orderid, DataTable dtData)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.SaveFinishedHandover(orderid, dtData));
        }

        public ServiceResultEntity CancelFinishedHandoverBarcode(string barcode)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.CancelFinishedHandoverBarcode(barcode));
        }

        public ServiceResultEntity SaveCancelFinishedHandoverByBarcode(string barcode)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.SaveCancelFinishedHandoverByBarcode(barcode));
        }

        public ServiceResultEntity SaveChangeFinishedHandoverByBarcode(string barcode, int orderid)
        {
            return this.Invoker.Invoke<ServiceResultEntity>(p => p.SaveChangeFinishedHandoverByBarcode(barcode, orderid));
        }
        #endregion

        /// <summary>
        /// 检验回收条码
        /// </summary>
        /// <param name="procedureID">工序ID</param>
        /// <param name="barcode">产品条码</param>
        /// <returns>DataSet</returns>
        public DataSet CheckRecydingFlagBarcode(int procedureID, string barcode)
        {
            return this.Invoker.Invoke<DataSet>(p => p.CheckRecydingFlagBarcode(procedureID, barcode));
        }

        /// <summary>
        /// 获取回收标识
        /// </summary>
        /// <param name="barcode">产品条码</param>ram>
        /// <returns>int</returns>
        public int GetRecyclingflagByBarcode(string barcode)
        {
            return this.Invoker.Invoke<int>(p => p.GetRecyclingflagByBarcode(barcode));
        }
    }
}