HEGII.ss.mes.wcf/WCF.Service/WCF.Services/PDAModuleService.cs

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

using System;
using System.Collections.Generic;
using System.Data;
using System.IO;
using System.ServiceModel;
using System.ServiceModel.Activation;
using Dongke.IBOSS.PRD.Basics.BaseResources;
using Dongke.IBOSS.PRD.Basics.Library;
using Dongke.IBOSS.PRD.Service.BarcodePrintService;
using Dongke.IBOSS.PRD.Service.CommonModuleLogic;
using Dongke.IBOSS.PRD.Service.DataModels;
using Dongke.IBOSS.PRD.Service.DKIBOSSPRDLogic;
using Dongke.IBOSS.PRD.Service.PCModuleLogic;
using Dongke.IBOSS.PRD.Service.PDAModuleLogic;
using Dongke.IBOSS.PRD.Service.PMModuleLogic;
using Dongke.IBOSS.PRD.Service.PublicModuleService;
using Dongke.IBOSS.PRD.Service.ReportModuleLogic;
using Dongke.IBOSS.PRD.Service.SmartDeviceService;
using Dongke.IBOSS.PRD.Service.SystemModuleLogic;
using Dongke.IBOSS.PRD.WCF.Contracts;
using Dongke.IBOSS.PRD.WCF.DataModels;
using Dongke.IBOSS.PRD.WCF.DataModels.ConfigModule;
using Dongke.IBOSS.PRD.WCF.DataModels.HRModule;
using Dongke.IBOSS.PRD.WCF.DataModels.PCModule;
using Dongke.IBOSS.PRD.WCF.DataModels.PMModule;

namespace Dongke.IBOSS.PRD.WCF.Services
{
    // 服务实现类,继承服务声明接口
    // 该标签声明该服务可以在ASP.NET下运行
    [AspNetCompatibilityRequirements(RequirementsMode = AspNetCompatibilityRequirementsMode.Allowed)]
    [ServiceBehavior(ConfigurationName = "PDAModuleService",
    InstanceContextMode = InstanceContextMode.PerCall,
    ConcurrencyMode = ConcurrencyMode.Multiple,
    UseSynchronizationContext = false)]
    public partial class PDAModuleService : IPDAModule
    {
        #region 属性

        /// <summary>
        /// 用户登陆的信息
        /// </summary>
        SUserInfo sUserInfo
        {
            get;
            set;
        }

        #endregion

        #region 构造函数
        /// <summary>
        /// 构造函数
        /// </summary>
        public PDAModuleService()
            : base()
        {
        }

        #endregion

        #region 验证

        /// <summary>
        /// 验证访问头
        /// </summary>
        /// <param name="accountCode">帐套编码</param>
        /// <param name="userCode">用户编码</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">访问密钥</param>
        /// <returns></returns>
        private ActionResult DoPDACheck(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            try
            {
                ActionResult actionResult = new ActionResult();

                LoginRequestEntity requestEntity = new LoginRequestEntity();
                requestEntity.AccountCode = accountCode;
                requestEntity.UserCode = userCode;
                requestEntity.Password = userPassword;
                requestEntity.SessionKey = sessionKey;
                SUserInfo userInfo = null;
                string loginStatus = DKIBOSSPRDLogic.AuthenticateRepeatLogin(requestEntity, out userInfo);

                // 用户登录信息错误
                if (Constant.INT_IS_ONE.ToString().Equals(loginStatus))
                {
                    actionResult.Status = (int)Constant.PDAResult.LoginInfoError;
                    actionResult.Message = Constant.PDA_RESULT_LOGININFOERROR;
                }
                // 用户在其它终端登陆
                else if (Constant.INT_IS_TWO.ToString().Equals(loginStatus))
                {
                    actionResult.Status = (int)Constant.PDAResult.RepeatLogin;
                    actionResult.Message = Constant.PDA_RESULT_REPEATLOGIN;
                }
                // Lic错误
                else if ("3".Equals(loginStatus))
                {
                    actionResult.Status = (int)Constant.PDAResult.LicInfoError;
                    actionResult.Message = "授权信息错误，请联系管理员。";
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }

                sUserInfo = userInfo;
                return actionResult;
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        #endregion

        #region WCF服务

        /// <summary>
        /// 测试PDA连接WCF服务
        /// </summary>
        /// <param name="value">测试文本</param>
        /// <returns>返回文本</returns>
        public string TestConnectionEx(string value)
        {
            return "连接成功！" + value;
        }

        public string TestConnection()
        {
            return "连接成功！";
        }

        #endregion

        #region 系统登录

        /// <summary>
        /// 系统登录
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="macAddress"></param>
        /// <param name="ipAddress"></param>
        /// <param name="phoneCode"></param>
        /// <param name="phoneType"></param>
        /// <param name="appVersion"></param>
        /// <param name="systemType"></param>
        /// <param name="systemVersion"></param>
        /// <returns></returns>
        public PDALoginResult DoPDALogin(string accountCode, string userCode, string userPassword,
            string macAddress, string ipAddress, string phoneCode, string phoneType,
            string appVersion, string systemType, string systemVersion)
        {
            try
            {
                LoginRequestEntity requestEntity = new LoginRequestEntity();
                requestEntity.AccountCode = accountCode;
                requestEntity.UserCode = userCode;
                requestEntity.Password = userPassword;
                requestEntity.ComputerName = phoneCode;
                requestEntity.IPAddress = ipAddress;
                requestEntity.MACAddress = macAddress;

                PDALoginResult result = ServiceInvoker.Invoke<PDALoginResult>(this,
                   () => PDAModuleLogic.DoPDALogin(requestEntity));

                return result;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                PDALoginResult result = new PDALoginResult();
                result.Status = (int)Constant.PDAResult.Exception;
                result.Message = Constant.PDA_RESULT_EXCEPTION;
                return result;
            }
        }

        /// <summary>
        /// 退出
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <returns></returns>
        public ActionResult DoPDAOut(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                bool result = DKIBOSSPRDLogic.Logout(sUserInfo.UserID, "3", sUserInfo);

                actionResult.Result = JsonHelper.ToJson(result);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 修改密码
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult ChangeUserPassword(string accountCode, string userCode, string userPassword, string sessionKey,
            string newPassWord)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                string result = ServiceInvoker.Invoke<string>(this,
                    () => SystemModuleDAL.SaveUserPassWord(newPassWord, userCode, null, sUserInfo));

                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取Apk信息
        /// </summary>
        /// <returns></returns>
        public string GetApkInfo()
        {
            try
            {
                ServiceResultEntity sre = PDAModuleLogic.GetApkInfo();
                return JsonHelper.ToJson(sre);
            }
            catch (Exception ex)
            {
                OutputLog.TraceLog(LogPriority.Error,
                    this.ToString(),
                    System.Reflection.MethodBase.GetCurrentMethod().Name,
                    ex.ToString(),
                    LocalPath.LogExePath);
                return null;
            }
        }

        #endregion

        #region 取得展示数据

        /// <summary>
        /// 获得生产线菜单
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <returns></returns>
        /// <remarks>
        /// 陈冰              2014.09.18              新建
        /// </remarks>
        public ActionResult GetProductionLineMenu(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                // 查询菜单
                DataTable dtPLM = ServiceInvoker.Invoke<DataTable>(this,
                   () => PDAModuleLogic.GetProductionLineMenu(sUserInfo));

                PDAFunctionResult pdaFunction = new PDAFunctionResult();
                pdaFunction.MenuCode = "Root";
                DataRow[] navigationRows = dtPLM.Select("LEN(MenuCode) = " + Constant.INT_IS_TWO.ToString(), "MenuCode ASC");   // 编号2为一级菜单
                foreach (DataRow newRow in navigationRows)
                {
                    #region 插入子节点数据
                    int? intProcedureID = null;
                    int? intModelType = null;
                    if (!string.IsNullOrEmpty(newRow["ProcedureID"].ToString()))
                    {
                        intProcedureID = Convert.ToInt32(newRow["ProcedureID"]);
                    }
                    if (!string.IsNullOrEmpty(newRow["ModelType"].ToString()))
                    {
                        intModelType = Convert.ToInt32(newRow["ModelType"]);
                    }
                    PDAFunctionResult pdaFunctionChild = new PDAFunctionResult();

                    //xuwei add 2020-01-02
                    pdaFunctionChild.IsGlazeChange = string.IsNullOrEmpty(newRow["IsGlazeChange"].ToString()) ? 0 : Convert.ToInt32(newRow["IsGlazeChange"].ToString());
                    //pdaFunctionChild.IsGlazeChange = 0;

                    pdaFunctionChild.MenuCode = newRow["MenuCode"].ToString();
                    pdaFunctionChild.MenuName = newRow["MenuName"].ToString();
                    pdaFunctionChild.ProcedureID = intProcedureID;
                    pdaFunctionChild.ProcedureModel = newRow["ProcedureModel"].ToString();
                    pdaFunctionChild.ModelType = intModelType;
                    pdaFunction.PDAFunctions.Add(pdaFunctionChild);
                    #endregion

                    InitTreeView(dtPLM, newRow["MenuCode"].ToString(), pdaFunctionChild);
                }
                //actionResult.Result = JsonHelper.ToJson(dtPLM);
                actionResult.Result = JsonHelper.ToJson(pdaFunction);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 初始化树形控件
        /// </summary>
        /// <param name="treeTable">菜单数据表</param>
        /// <param name="rows">待处理的菜单集合</param>
        /// <param name="node">当前树节点</param>
        private void InitTreeView(DataTable treeTable, string pFuncCode, PDAFunctionResult pFunctions)
        {
            string filterExpression = "MenuCode LIKE '" + pFuncCode + "%' AND LEN(MenuCode) = "
                    + (pFuncCode.Length + Constant.INT_IS_TWO);
            DataRow[] subRows = treeTable.Select(filterExpression, "MenuCode ASC");
            //DataRow[] subRows = treeTable.Select(filterExpression, "ProcedureCode ASC");
            foreach (DataRow newRow in subRows)
            {
                #region 插入子节点数据
                int? intProcedureID = null;
                int? intModelType = null;
                if (!string.IsNullOrEmpty(newRow["ProcedureID"].ToString()))
                {
                    intProcedureID = Convert.ToInt32(newRow["ProcedureID"]);
                }
                if (!string.IsNullOrEmpty(newRow["ModelType"].ToString()))
                {
                    intModelType = Convert.ToInt32(newRow["ModelType"]);
                }
                PDAFunctionResult pdaFunctionChild = new PDAFunctionResult();

                //xuwei add 2020-01-02
                pdaFunctionChild.IsGlazeChange = string.IsNullOrEmpty(newRow["IsGlazeChange"].ToString()) ? 0 : Convert.ToInt32(newRow["IsGlazeChange"].ToString());
                //pdaFunctionChild.IsGlazeChange = 0;

                pdaFunctionChild.MenuCode = newRow["MenuCode"].ToString();
                pdaFunctionChild.MenuName = newRow["MenuName"].ToString();
                pdaFunctionChild.ProcedureID = intProcedureID;
                pdaFunctionChild.ProcedureModel = newRow["ProcedureModel"].ToString();
                pdaFunctionChild.ModelType = intModelType;
                pFunctions.PDAFunctions.Add(pdaFunctionChild);
                #endregion

                // 递归方法
                InitTreeView(treeTable, newRow["MenuCode"].ToString(), pdaFunctionChild);
            }
        }

        #endregion

        #region 获得工序信息

        /// <summary>
        /// 获得工序信息
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">工序ID</param>
        /// <returns></returns>
        /// <remarks>
        /// 陈冰              2014.09.18              新建
        /// </remarks>
        public ActionResult GetProcedureByID(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                ProcedureEntity procedureEntity = ServiceInvoker.Invoke<ProcedureEntity>(this,
                   () => PMModuleLogic.GetProcedureDataEntityByID(procedureID, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(procedureEntity);

                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #endregion

        #region 校验

        /// <summary>
        /// 校验产品条码是否可以走到该工序
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">工序ID</param>
        /// <param name="barcode">条码</param>
        /// <returns></returns>
        /// <remarks>
        /// 陈冰              2014.09.18              新建
        /// </remarks>
        public ActionResult CheckBarcode(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID, string barcode, bool isNewCheck)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet barcodeDataSet = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.CheckBarcodePDA(procedureID, barcode, sUserInfo));

                if (barcodeDataSet != null && barcodeDataSet.Tables.Count > Constant.INT_IS_ZERO)
                {
					if (isNewCheck)
					{
                        actionResult.Result = JsonHelper.ToJson(barcodeDataSet);

                    }
					else
					{
                        actionResult.Result = JsonHelper.ToJson(barcodeDataSet.Tables[0]);

                    }
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }


        /// <summary>
        /// 校验产品条码是否可以进行干补
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">工序ID</param>
        /// <param name="barcode">条码</param>
        /// <returns></returns>
        /// <remarks>
        /// 袁新成              2015.4.1             新建
        /// </remarks>
        public ActionResult CheckDryRepairBarcode(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet barcodeDataSet = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.CheckDryRepairBarcode(procedureID, barcode, sUserInfo));

                if (barcodeDataSet != null && barcodeDataSet.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(barcodeDataSet.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 检验生产工号
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">工序ID</param>
        /// <param name="procedureUserCode">生产工号</param>
        /// <remarks>
        /// 陈冰              2014.09.18              新建
        /// </remarks>
        public ActionResult CheckProcedureUser(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID, string procedureUserCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                CheckProcedureUserResult checkProcedureUserResult = ServiceInvoker.Invoke<CheckProcedureUserResult>(this,
                   () => PMModuleLogic.CheckProcedureUser(procedureID, procedureUserCode, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(checkProcedureUserResult);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 校验窑车是否可装车并返回窑车信息
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="kilnCarCode">窑车号</param>
        /// <param name="modelType">工序类别</param>
        /// <returns></returns>
        /// <remarks>
        /// 陈冰              2014.10.04              新建
        /// </remarks>
        public ActionResult CheckKilnCar(string accountCode, string userCode, string userPassword, string sessionKey, int pProcedureId, string kilnCarCode, int modelType)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                CheckKilnCarResultEntity checkKilnCarResultEntity = ServiceInvoker.Invoke<CheckKilnCarResultEntity>(this,
                   () => PMModuleLogic.CheckKilnCar(pProcedureId, kilnCarCode, modelType, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(checkKilnCarResultEntity);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #endregion

        #region 保存条码信息

        /// <summary>
        /// 保存条码信息
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">工序ID</param>
        /// <param name="productionDataEntitys">条码信息</param>
        public ActionResult AddWorkPiece(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID,
            ProductionDataEntity[] productionDataEntitys)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataTable dtProductionData = DataConvert.ObjectConvertToTable<ProductionDataEntity>(productionDataEntitys);
                if (!dtProductionData.Columns.Contains("IsPDA"))
                {
                    dtProductionData.Columns.Add("IsPDA");
                }
                ProcedureEntity procedureInfo = null;
                DataTable resultDT = ServiceInvoker.Invoke<DataTable>(this,
                   () => PMModuleLogicDAL.AddWorkPiece(procedureID, dtProductionData, sUserInfo, out procedureInfo));
                actionResult.Result = JsonHelper.ToJson(resultDT);
                actionResult.Status = (int)Constant.PDAResult.Success;

                if (resultDT != null)
                {
                    DataRow[] drs = resultDT.Select("out_errMsg is not null and out_errMsg <> ''");
                    if (drs != null && drs.Length > 0)
                    {
                        return actionResult;
                    }
                }

                #region PDA条码打印
                if (procedureInfo != null && procedureInfo.BarCodePrintCopies > 0 &&
                    procedureInfo.ModelType == (int)Constant.ProcedureModelType.Normal)
                {
                    try
                    {
                        if (procedureInfo.CollectType == 1)
                        {
                            //foreach (DataRow item in dtProductionData.Rows)
                            //{
                            //    ServiceResultEntity sre = BarcodePrintLogic.PrintBarcode(item["barcode"].ToString(),
                            //        procedureInfo.BarCodePrintCopies, null, sUserInfo);
                            //    if (sre.Status != Constant.ServiceResultStatus.Success)
                            //    {
                            //        actionResult.Status = (int)Constant.ServiceResultStatus.Other;
                            //        actionResult.Message = sre.Message;
                            //        return actionResult;
                            //    }
                            //}
                        }
                        else
                        {
                            //ServiceResultEntity sre = BarcodePrintLogic.PrintBarcode(dtProductionData.Rows[0]["barcode"].ToString(),
                            //           procedureInfo.BarCodePrintCopies, null, sUserInfo);
                            ServiceResultEntity sre = BarcodePrintLogic.PrintBarcode_3C(dtProductionData.Rows[0]["barcode"].ToString(),
                                       procedureInfo.BarCodePrintCopies, null, sUserInfo, 0);
                            if (sre.Status != Constant.ServiceResultStatus.Success)
                            {
                                actionResult.Status = (int)Constant.ServiceResultStatus.Other;
                                actionResult.Message = sre.Message;
                                return actionResult;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        OutputLog.TraceLog(LogPriority.Error,
                                        this.ToString(),
                                        System.Reflection.MethodBase.GetCurrentMethod().Name,
                                        ex.ToString(),
                                        LocalPath.LogExePath);
                        actionResult.Status = (int)Constant.ServiceResultStatus.Other;
                        actionResult.Message = "条码打印异常";
                        return actionResult;
                    }
                }
                #endregion PDA条码打印
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                try
                {
                    string ss = JsonHelper.ToJson(productionDataEntitys);
                    OutputLog.TraceLog(LogPriority.Error,
                                    this.ToString(),
                                    System.Reflection.MethodBase.GetCurrentMethod().Name,
                                    $" userCode:{userCode} procedureID:{procedureID} " + ss,
                                    LocalPath.LogExePath);
                }
                catch
                {
                }
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #endregion

        #region 获得系统/基数数据

        /// <summary>
        /// 获得数据字典
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="dicType">字典类型</param>
        /// <returns></returns>
        public ActionResult GetDataDictionaryByType(string accountCode, string userCode, string userPassword, string sessionKey, string dicType)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataTable dicDataTable = ServiceInvoker.Invoke<DataTable>(this,
                   () => CommonModuleLogic.GetDataDictionaryByType(sUserInfo, dicType));

                actionResult.Result = JsonHelper.ToJson(dicDataTable);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #endregion

        #region 检验工序接口

        /// <summary>
        /// 获得检验标识
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <returns></returns>
        /// <remarks>
        /// 陈冰              2014.10.04              新建
        /// </remarks>
        public ActionResult GetDefectFlagData(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                #region 构造缺陷标识的数据源
                DataTable dtDefectFlag = CreateDataSource.GetDefectFlagTable();
                #endregion

                actionResult.Result = JsonHelper.ToJson(dtDefectFlag);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 由条码和当前检验工序获取返工工序
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">当前检验工序ID</param>
        /// <param name="barcode">条码</param>
        /// <returns></returns>
        /// <remarks>
        /// 陈冰              2014.10.04              新建
        /// </remarks>
        public ActionResult GetReworkProcedureByBarcode(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetReworkProcedureByBarcode(procedureID, barcode));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 由当前检验工序获取缺陷列表
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">当前检验工序ID</param>
        /// <param name="defectCode">缺陷编码</param>
        /// <returns></returns>
        /// <remarks>
        /// 陈冰              2014.10.04              新建
        /// </remarks>
        public ActionResult GetDefectByProcedureIDAndDefectCode(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID, string defectCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                object defectDs = ServiceInvoker.Invoke<object>(this,
                   () => PMModuleLogic.GetDefectByProcedureIDAndDefectCode(procedureID, defectCode));
                if (defectDs != null)
                {
                    actionResult.Result = JsonHelper.ToJson(defectDs);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 根据产品ID查出缺陷位置
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="goodsID">产品ID</param>
        /// <param name="positionCode">位置编码</param>
        /// <returns></returns>
        /// <remarks>
        /// 陈冰              2014.10.04              新建
        /// </remarks>
        public ActionResult GetDefectPositionByGoodsIDAndPositionCode(string accountCode, string userCode, string userPassword, string sessionKey, int goodsID, string positionCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                // 缺陷位置已经不用在关联产品
                //object defectDs = ServiceInvoker.Invoke<object>(this,() => PMModuleLogic.GetDefectPositionByGoodsIDAndPositionCode(goodsID, positionCode));
                object defectDs = ServiceInvoker.Invoke<object>(this, () => PMModuleLogic.GetDefectPosition(positionCode, sUserInfo));

                if (defectDs != null)
                {
                    actionResult.Result = JsonHelper.ToJson(defectDs);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 通过条码和缺陷查出责任工序
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="barcode">条码</param>
        /// <param name="defectid">缺陷ID</param>
        /// <returns></returns>
        /// <remarks>
        /// 陈冰              2014.10.04              新建
        /// </remarks>
        public ActionResult GetDutyProcedureByBarCode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode, int defectid)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet dutyProcedureDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetDutyProcedureByBarCode(barcode, defectid, sUserInfo.AccountID));
                if (dutyProcedureDs != null && dutyProcedureDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(dutyProcedureDs);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 通过条码与工序查出责任工号(己废)
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="barcode">条码</param>
        /// <param name="dutyProcedureID">责任工序</param>
        /// <returns></returns>
        /// <remarks>
        /// 陈冰              2014.10.04              新建
        /// </remarks>
        public ActionResult GetDutyProcedureCodeByBarCode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode, int dutyProcedureID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet dutyProcedureDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetDutyProcedureCodeByBarCode(barcode, dutyProcedureID));
                if (dutyProcedureDs != null && dutyProcedureDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(dutyProcedureDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 通过条码与工序查出责任工号
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="ProductionDataID">生产数据ID</param>
        /// <returns></returns>

        public ActionResult GetDutyProcedureCodeByProductionDataID(string accountCode, string userCode, string userPassword, string sessionKey, int ProductionDataID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet dutyProcedureDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetDutyProcedureCodeByProductionDataID(ProductionDataID));
                if (dutyProcedureDs != null && dutyProcedureDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(dutyProcedureDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }



        /// <summary>
        /// 通过生产数据与工号ID查询工种
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="productionDataID">生产数据ID</param>
        /// <param name="userID">工号ID</param>
        /// <returns></returns>
        /// <remarks>
        /// 陈冰              2014.10.08              新建
        /// </remarks>
        public ActionResult GetDutyJobsByUserIDAndProductionID(string accountCode, string userCode, string userPassword, string sessionKey,
            //int productionDataID, int userID)
            int classesSettingID, int defectid, int procedureID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet dutyProcedureDs = ServiceInvoker.Invoke<DataSet>(this,
                   //() => PMModuleLogic.GetDutyJobsCodeByUser(userID, productionDataID));
                   () => PDAModuleLogic.GetDutyJobsCodeByUser(classesSettingID, defectid, procedureID));
                if (dutyProcedureDs != null && dutyProcedureDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(dutyProcedureDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 根据生产数据ID，用户ID及工种选出责任员工
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="productionDataID">生产数据ID</param>
        /// <param name="userID">工号ID</param>
        /// <param name="jobsID">工种ID</param>
        /// <returns></returns>
        /// <remarks>
        /// 陈冰              2014.10.08              新建
        /// </remarks>
        public ActionResult GetDutyStaffByUserIDAndJobs(string accountCode, string userCode, string userPassword, string sessionKey,
            //int productionDataID, int userID, int jobsID)
            int classesSettingID, int jobsID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet dutyProcedureDs = ServiceInvoker.Invoke<DataSet>(this,
                   //() => PMModuleLogic.GetDutyStaffByUserIDAndJobs(productionDataID, userID, jobsID));
                   () => PDAModuleLogic.GetDutyStaffByUserIDAndJobs(classesSettingID, jobsID));
                if (dutyProcedureDs != null && dutyProcedureDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(dutyProcedureDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获得产品分级
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <returns></returns>
        /// <remarks>
        /// 陈冰              2014.10.08              新建
        /// xuwei 2019-12-4 添加参数type 默认为2成检 为1时 半检
        /// </remarks>
        public ActionResult GetGoodsGradeData(string accountCode, string userCode, string userPassword, string sessionKey, int type = 2)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                #region 构造产品分级的数据源
                //DataTable dtGrade = CreateDataSource.GetGoodsGradeTable();
                //xuwei modify 2019-12-04 支持半检 没传参数 type=0 
                //DataSet dsGrade = SystemModuleLogic.GetGoodsLevel(2 , sUserInfo);
                DataSet dsGrade = SystemModuleLogic.GetGoodsLevel(type == 0 ? 2 : type, sUserInfo);

                if (dsGrade != null && dsGrade.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(dsGrade.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
                #endregion

            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #endregion

        #region 保存检验条码

        /// <summary>
        /// 保存检验条码
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">工序ID</param>
        /// <param name="productionDataEntitys">条码信息</param>
        /// <returns></returns>
        public ActionResult AddCheckBarcode(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID, ProductionDataEntity[] productionDataEntitys)
        {
            ActionResult actionResult = new ActionResult();
            if (productionDataEntitys == null || productionDataEntitys.Length == 0 ||
                string.IsNullOrWhiteSpace(productionDataEntitys[0].Barcode))
            {
                actionResult.Status = (int)Constant.PDAResult.Fail;
                actionResult.Message = "无效条码";
                return actionResult;
            }
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                //if(productionDataEntitys.Length>0)
                //{
                //    if(productionDataEntitys[0].ProductionDataID>0)
                //    {
                //        productionDataEntitys[0].OPTimeStamp = Convert.ToDateTime(productionDataEntitys[0].OPTimeStampPDA.Replace("-","/"));
                //    }
                //}
                string err = ServiceInvoker.Invoke<string>(this,
                    //() => PMModuleLogicDAL.AddCheckBarcode(procedureID, productionDataEntitys, sUserInfo));
                    () => PMModuleLogicDAL.AddCheckBarcodePDA(procedureID, productionDataEntitys, sUserInfo));

                if (err == null)
                {
                    err = "";
                }
                if (err == "DataDouble")
                {
                    actionResult.Result = string.Format(Messages.MSG_HR_W006, "成检", "保存");
                    actionResult.Status = 2;
                    return actionResult;
                }
                else if (!string.IsNullOrEmpty(err))
                {
                    actionResult.Result = err;
                    actionResult.Message = err;
                    actionResult.Status = 666;
                    return actionResult;
                }

                //actionResult.Result = JsonHelper.ToJson(err);
                actionResult.Result = err;// JsonHelper.ToJson(err);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 保存检验条码
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">工序ID</param>
        /// <param name="productionDataEntitys">条码信息</param>
        /// <returns></returns>
        public ActionResult AddBarcodeIdnrkScrap(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID, ProductionDataEntity[] productionDataEntitys)
        {
            ActionResult actionResult = new ActionResult();
            if (productionDataEntitys == null || productionDataEntitys.Length == 0 ||
                string.IsNullOrWhiteSpace(productionDataEntitys[0].Barcode))
            {
                actionResult.Status = (int)Constant.PDAResult.Fail;
                actionResult.Message = "无效条码";
                return actionResult;
            }
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                string err = ServiceInvoker.Invoke<string>(this,
                    () => PMModuleLogicDAL.AddBarcodeIdnrkScrapPDA(procedureID, productionDataEntitys, sUserInfo));

                if (err == null)
                {
                    err = "";
                }

                actionResult.Result = err;
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #endregion

        #region 文件上传下载

        /// <summary>
        /// 软件更新
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <returns></returns>
        public Stream AutoUpgrade(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            try
            {
                return ServiceInvoker.Invoke<Stream>(this, () => PDAModuleLogic.AutoUpgrade());
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                return null;
            }
        }

        /// <summary>
        /// 上传临时文件
        /// </summary>
        /// <param name="imgStream"></param>
        /// <returns></returns>
        public ActionResult SaveImg(Stream mageStream)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                string err = PDAModuleLogic.SaveImg(mageStream);

                if (err == null)
                {
                    err = "";
                }

                actionResult.Result = err;
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        public Stream GetFileTest(string path)
        {
            return PDAModuleLogic.GetImg(path);
        }

        public Stream GetFileStream()
        {
            FileStream fs = new FileStream("999.apk", FileMode.OpenOrCreate, FileAccess.Read);
            long l = fs.Length;
            return fs;
        }

        public byte[] GetFileTestByte(string path)
        {
            FileStream stream = new FileInfo(path).OpenRead();
            Byte[] buffer = new Byte[stream.Length];
            //从流中读取字节块并将该数据写入给定缓冲区buffer中
            stream.Read(buffer, 0, Convert.ToInt32(stream.Length));
            return buffer;
        }

        public string GetFile(string path)
        {
            string imgFilePath = path;

            System.IO.FileStream fs = new System.IO.FileStream(imgFilePath, System.IO.FileMode.Open);
            int i = (int)fs.Length;
            byte[] content = new byte[i];
            fs.Read(content, 0, i);
            string result = Convert.ToBase64String(content);
            fs.Close();
            FileStream fsTxt = new FileStream("A.txt", FileMode.OpenOrCreate);
            StreamWriter sw = new StreamWriter(fsTxt, System.Text.Encoding.Default);
            sw.Write(result);
            sw.Close();
            fsTxt.Close();
            return result;
        }

        #endregion

        /// <summary>
        /// 获得产品分级
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">当前工序ID</param>
        /// <returns></returns>
        /// <remarks>
        /// 陈冰              2014.10.22              新建
        /// </remarks>
        public ActionResult GetReworkProcedureByProcedureID(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetReworkProcedureByProcedureID(procedureID));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获得产品分级
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="barcode">条码</param>
        /// <returns></returns>
        public ActionResult GetKilnCarByBarCode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetKilnCarByBarCode(barcode));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #region 统计

        /// <summary>
        /// 统计当日计数数量
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">工序ID</param>
        /// <returns></returns>
        public ActionResult StatisticsCollectBarcode(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.StatisticsCollectBarcode(procedureID, sUserInfo));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 统计当日计数数量
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">工序ID</param>
        /// <returns></returns>
        public ActionResult StatisticsKilnCar(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.StatisticsKilnCar(procedureID, sUserInfo));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 统计产品跟踪
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">工序ID</param>
        /// <returns></returns>
        public ActionResult StatisticsProductTrack(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                RPT020101_SE se = new RPT020101_SE();
                se.Barcode = barcode;

                ServiceResultEntity sre = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                 () => Dongke.IBOSS.PRD.Service.ReportModuleLogic.ReportModuleLogic.GetRPT020101SData(sUserInfo, se));
                if (sre.Status == Constant.ServiceResultStatus.NoSearchResults)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Messages.MSG_CMN_I002;
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(sre.Data);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                //ProductionDataEntity productionDataEntity = ServiceInvoker.Invoke<ProductionDataEntity>(this,
                //   () => PDAModuleLogic.StatisticsProductTrack(barcode, sUserInfo));
                //if (productionDataEntity != null)
                //{
                //    actionResult.Result = JsonHelper.ToJson(productionDataEntity);
                //    actionResult.Status = (int)Constant.PDAResult.Success;
                //}
                //else
                //{
                //    actionResult.Status = (int)Constant.PDAResult.Fail;
                //    actionResult.Message = Messages.MSG_CMN_I002;
                //}
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString() + ex.HelpLink,
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #endregion

        #region 撤销装车及成检

        /// <summary>
        /// 检验条码是否可以撤销装车
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">当前工序ID</param>
        /// <param name="barcode">条码</param>
        /// <returns></returns>
        public ActionResult CheckCancelLoadCar(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                CheckCancelLoadCar checkCancelLoadCar = ServiceInvoker.Invoke<CheckCancelLoadCar>(this,
                   () => PMModuleLogic.CheckCancelLoadCar(procedureID, barcode, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(checkCancelLoadCar);
                actionResult.Status = (int)Constant.PDAResult.Success;

            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 保存撤销装车的条码
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">当前工序ID</param>
        /// <param name="barcode">条码</param>
        /// <returns></returns>
        public ActionResult AddCancelLoadCar(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                string err = ServiceInvoker.Invoke<string>(this,
                   () => PMModuleLogicDAL.AddCancelLoadCar(procedureID, barcode, sUserInfo));

                if (err == null)
                {
                    err = "";
                }

                actionResult.Result = JsonHelper.ToJson(err);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 由产品条码获取注浆信息
        /// </summary>
        /// <param name="barcode"></param>
        /// <returns></returns>
        public ActionResult GetGroutingProducttByBarCode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetGroutingProducttByBarCode(barcode));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取工号下的所有工种信息
        /// </summary>
        /// <param name="UserID">工号ID</param>
        /// <returns></returns>
        public ActionResult GetAllJobsByUserID(string accountCode, string userCode, string userPassword, string sessionKey, int UserID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetAllJobsByUserID(UserID, sUserInfo));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 根据所选工号对应的工种，查出缺陷责任员工
        /// </summary>
        /// <param name="jobs">工种ID</param>
        /// <returns></returns>
        public ActionResult GetDutyStaffByUserID(string accountCode, string userCode, string userPassword, string sessionKey, int jobs)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetDutyStaffByUserID(jobs, sUserInfo));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }


        /// <summary>
        /// 根据所选工号，查出漏检责任员工
        /// </summary>
        /// <param name="userid">工号</param>
        /// <returns></returns>
        public ActionResult GetMissedStaffByUserID(string accountCode, string userCode, string userPassword, string sessionKey, int userid)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetMissedStaffByUserID(userid, sUserInfo));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取用户列表
        /// </summary>
        /// <param name="requestEntity">用户实体</param>
        /// <returns></returns>
        public ActionResult SearchUserData(string accountCode, string userCode, string userPassword, string sessionKey, byte IsWorker)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                SUserEntity requestEntity = new SUserEntity();
                requestEntity.IsWorker = IsWorker;
                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.SearchUserData(requestEntity, sUserInfo));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取数据字典管理的数据
        /// </summary>
        /// <param name="Pvalue">显示停用标识</param>
        /// <param name="dictionaryType">字典类别</param>
        /// <returns></returns>
        /// <remarks>
        /// 2014.12.03          新建
        /// </remarks>
        public ActionResult GetDictionaryData(string accountCode, string userCode, string userPassword, string sessionKey, byte Pvalue, string dictionaryType)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetDictionaryData(Pvalue, dictionaryType, sUserInfo));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #endregion

        #region 保存半检数据

        /// <summary>
        /// 保存半检数据
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="productionDataEntitys">半检信息</param>
        /// <returns></returns>
        public ActionResult AddSemiTest(string accountCode, string userCode, string userPassword, string sessionKey, SemiTestEntity[] semiTestEntitys)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                string err = ServiceInvoker.Invoke<string>(this,
                   () => PMModuleLogicDAL.AddSemiTest(semiTestEntitys, sUserInfo));

                if (err == null)
                {
                    err = "";
                }

                actionResult.Result = JsonHelper.ToJson(err);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #endregion

        /// <summary>
        /// 获取产品列表
        /// </summary>
        /// <returns></returns>
        public ActionResult SerachGoods(string accountCode, string userCode, string userPassword, string sessionKey, int valueFlag)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                GoodsEntity goodsEntity = new GoodsEntity();
                goodsEntity.ValueFlag = 1;//有效标记
                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.SerachGoods(sUserInfo, goodsEntity));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 使用存储过程PRO_PM_GetProductionData获取生产工序计件数据
        /// </summary>
        /// <param name="searchEntity">生产数据实体类</param>
        /// <returns>DataTable</returns>
        public ActionResult GetProductionData(string accountCode, string userCode, string userPassword, string sessionKey, int ProcedureID, string BarCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                SearchProductionDataEntity searchEntity = new SearchProductionDataEntity();
                searchEntity.ProcedureID = ProcedureID;
                searchEntity.BarCode = BarCode;
                DataTable reworkDs = ServiceInvoker.Invoke<DataTable>(this,
                   () => PDAModuleLogic.GetProductionData(searchEntity, sUserInfo));
                if (reworkDs != null && reworkDs.Rows.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_ALLOW_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        ///  xuwei add 2020-03-23 此方法用于成检后 回收 再次成检 获取正确ID
        /// </summary>
        /// <param name="searchEntity">生产数据实体类</param>
        /// <returns>DataTable</returns>
        public ActionResult GetProductionDataCheckID(string accountCode, string userCode, string userPassword, string sessionKey, string BarCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                SearchProductionDataEntity searchEntity = new SearchProductionDataEntity();
                searchEntity.BarCode = BarCode;
                DataTable reworkDs = ServiceInvoker.Invoke<DataTable>(this,
                   () => PDAModuleLogic.GetProductionDataCheckID(searchEntity, sUserInfo));
                if (reworkDs != null && reworkDs.Rows.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_ALLOW_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 根据所选生产数据ID,显示成检数据信息
        /// </summary>
        /// <param name="productionDataID">生产数据ID</param>
        /// <returns>DataSet</returns>
        public ActionResult GetProductionDataByID(string accountCode, string userCode, string userPassword, string sessionKey, int productionDataID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetProductionDataByID(productionDataID));
                PDAProductionDataResult productionDatas = new PDAProductionDataResult();
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    if (reworkDs != null && reworkDs.Tables[0].Rows.Count > Constant.INT_IS_ZERO)
                    {
                        for (int i = 0; i < reworkDs.Tables[0].Rows.Count; i++)
                        {
                            PDAProductionDataResult productionData = new PDAProductionDataResult();
                            productionData.BarCode = reworkDs.Tables[0].Rows[i]["BarCode"].ToString();
                            if (reworkDs.Tables[0].Rows[i]["GoodsID"].ToString() != "")
                            {
                                productionData.GoodsID = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["GoodsID"].ToString());
                            }
                            productionData.GoodsCode = reworkDs.Tables[0].Rows[i]["GoodsCode"].ToString();
                            productionData.GoodsName = reworkDs.Tables[0].Rows[i]["GoodsName"].ToString();
                            if (reworkDs.Tables[0].Rows[0]["DefectFlagID"].ToString() != "")
                            {
                                productionData.DefectFlagID = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["DefectFlagID"].ToString());
                            }
                            if (reworkDs.Tables[0].Rows[i]["ReworkProcedureID"].ToString() != "")
                            {
                                productionData.ReworkProcedureID = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["ReworkProcedureID"].ToString());
                            }
                            productionData.Remarks = reworkDs.Tables[0].Rows[i]["Remarks"].ToString();
                            if (reworkDs.Tables[0].Rows[i]["UserID"].ToString() != "")
                            {
                                productionData.UserID = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["UserID"].ToString());
                            }
                            if (reworkDs.Tables[0].Rows[i]["GoodsLevelTypeID"].ToString() != "")
                            {
                                productionData.GoodsLevelTypeID = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["GoodsLevelTypeID"].ToString());
                            }
                            productionData.UserCode = reworkDs.Tables[0].Rows[i]["UserCode"].ToString();
                            productionData.UserName = reworkDs.Tables[0].Rows[i]["UserName"].ToString();
                            productionData.SpecialRepairflag = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["SpecialRepairflag"]);
                            productionData.IsReFire = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["IsReFire"]);
                            productionData.KilnCarCode = reworkDs.Tables[0].Rows[i]["KilnCarCode"].ToString();
                            productionData.KilnCode = reworkDs.Tables[0].Rows[i]["KilnCode"].ToString();
                            productionData.GlazeName = reworkDs.Tables[0].Rows[i]["GlazeName"].ToString();

                            productionData.LeakFlag1 = reworkDs.Tables[0].Rows[i]["LeakFlag1"].ToString();
                            productionData.LeakFlag2 = reworkDs.Tables[0].Rows[i]["LeakFlag2"].ToString();
                            productionData.LeakFlag3 = reworkDs.Tables[0].Rows[i]["LeakFlag3"].ToString();
                            productionData.SpecialRepairFlagName = reworkDs.Tables[0].Rows[i]["specialRepairFlagName"].ToString();
                            productionData.IsReFireName = reworkDs.Tables[0].Rows[i]["isReFireName"].ToString();
                            productionData.LeakFlag1Name = reworkDs.Tables[0].Rows[i]["LeakFlag1Name"].ToString();
                            productionData.LeakFlag2Name = reworkDs.Tables[0].Rows[i]["LeakFlag2Name"].ToString();
                            productionData.LeakFlag3Name = reworkDs.Tables[0].Rows[i]["LeakFlag3Name"].ToString();

                            if (reworkDs.Tables[0].Rows[i]["logoid"].ToString() != "")
                            {
                                productionData.LogoID = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["logoid"]);
                                productionData.LogoCode = reworkDs.Tables[0].Rows[i]["LogoCode"].ToString();
                                productionData.LogoName = reworkDs.Tables[0].Rows[i]["LogoName"].ToString();
                            }
                            productionData.CreateTime = Convert.ToDateTime(reworkDs.Tables[0].Rows[i]["CreateTime"]);
                            if (reworkDs.Tables[0].Rows[i]["CheckTime"].ToString() != "")
                            {
                                productionData.CheckTime = Convert.ToDateTime(reworkDs.Tables[0].Rows[i]["CheckTime"].ToString());
                            }
                            DataView dvDefect = reworkDs.Tables[1].DefaultView;
                            dvDefect.RowFilter = "BarCode=" + reworkDs.Tables[0].Rows[i]["BarCode"].ToString();
                            DataTable dtDefect = dvDefect.ToTable();
                            for (int row = 0; row < dtDefect.Rows.Count; row++)
                            {
                                // 产品缺陷
                                PDADefectResult defect = new PDADefectResult();
                                defect.SpecialDefect = dtDefect.Rows[row]["SpecialDefect"].ToString();
                                defect.DefectDeductionNum = Convert.ToDecimal(dtDefect.Rows[row]["DefectDeductionNum"].ToString());
                                if (dtDefect.Rows[row]["ProductionDefectID"].ToString() != "")
                                {
                                    defect.ProductionDefectID = Convert.ToInt32(dtDefect.Rows[row]["ProductionDefectID"].ToString());
                                }
                                defect.BarCode = dtDefect.Rows[row]["BarCode"].ToString();
                                if (dtDefect.Rows[row]["DefectID"].ToString() != "")
                                {
                                    defect.DefectID = Convert.ToInt32(dtDefect.Rows[row]["DefectID"].ToString());
                                }
                                defect.DefectName = dtDefect.Rows[row]["DefectName"].ToString();
                                defect.DefectCode = dtDefect.Rows[row]["DefectCode"].ToString();
                                if (dtDefect.Rows[row]["DefectPositionID"].ToString() != "")
                                {
                                    defect.DefectPositionID = Convert.ToInt32(dtDefect.Rows[row]["DefectPositionID"].ToString());
                                }
                                defect.DefectPositionName = dtDefect.Rows[row]["DefectPositionName"].ToString();
                                defect.DefectPositionCode = dtDefect.Rows[row]["DefectPositionCode"].ToString();
                                if (dtDefect.Rows[row]["DefectProcedureID"].ToString() != "")
                                {
                                    defect.DefectProcedureID = Convert.ToInt32(dtDefect.Rows[row]["DefectProcedureID"].ToString());
                                }
                                defect.DefectProcedureName = dtDefect.Rows[row]["DefectProcedureName"].ToString();
                                defect.DefectProcedureCode = dtDefect.Rows[row]["DefectProcedureCode"].ToString();
                                if (dtDefect.Rows[row]["DefectUserID"].ToString() != "")
                                {
                                    defect.DefectUserID = Convert.ToInt32(dtDefect.Rows[row]["DefectUserID"].ToString());
                                }
                                defect.DefectUserName = dtDefect.Rows[row]["DefectUserName"].ToString();
                                defect.DefectUserCode = dtDefect.Rows[row]["DefectUserCode"].ToString();
                                if (dtDefect.Rows[row]["Jobs"].ToString() != "")
                                {
                                    defect.Jobs = Convert.ToInt32(dtDefect.Rows[row]["Jobs"].ToString());
                                }
                                if (dtDefect.Rows[row]["MissedUserID"].ToString() != "")
                                {
                                    defect.MissedUserID = Convert.ToInt32(dtDefect.Rows[row]["MissedUserID"].ToString());
                                }
                                defect.MissedUserCode = dtDefect.Rows[row]["MissedUserCode"].ToString();
                                defect.MissedUserName = dtDefect.Rows[row]["MissedUserName"].ToString();
                                defect.JobsText = dtDefect.Rows[row]["JobsText"].ToString();
                                defect.DefectRemarks = dtDefect.Rows[row]["DefectRemarks"].ToString();

                                if (dtDefect.Rows[row]["ProductionDataID"].ToString() != "")
                                {
                                    defect.ProductionDataID = Convert.ToInt32(dtDefect.Rows[row]["ProductionDataID"].ToString());
                                }

                                if (dtDefect.Rows[row]["DefectProductionDataID"].ToString() != "")
                                {
                                    defect.DefectProductionDataID = Convert.ToInt32(dtDefect.Rows[row]["DefectProductionDataID"].ToString());
                                }

                                if (dtDefect.Rows[row]["DefectFineID"].ToString() != "")
                                {
                                    defect.DefectFineID = Convert.ToInt32(dtDefect.Rows[row]["DefectFineID"].ToString());
                                }
                                defect.DefectFineValue = dtDefect.Rows[row]["DefectFineValue"].ToString();
                                defect.CheckTime = Convert.ToDateTime(dtDefect.Rows[row]["CheckTime"]);
                                //--------责任员工-------------------
                                DataRow[] drRow = reworkDs.Tables[2].Select("ProductionDefectID=" + reworkDs.Tables[1].Rows[row]["ProductionDefectID"]);
                                if (drRow.Length > Constant.INT_IS_ZERO)
                                {
                                    foreach (DataRow r in drRow)
                                    {
                                        PDADefectResponsibleResult defectResponsible = new PDADefectResponsibleResult();
                                        if (r["ProductionDefectID"].ToString() != "")
                                        {
                                            defectResponsible.ProductionDefectID = Convert.ToInt32(r["ProductionDefectID"]);
                                        }
                                        if (r["StaffID"].ToString() != "")
                                        {
                                            defectResponsible.StaffID = Convert.ToInt32(r["StaffID"]);
                                        }
                                        defectResponsible.StaffCode = r["StaffCode"].ToString();
                                        defectResponsible.StaffName = r["StaffName"].ToString();
                                        if (r["StaffStatus"].ToString() != "")
                                        {
                                            defectResponsible.StaffStatus = Convert.ToInt32(r["StaffStatus"]);
                                        }
                                        if (r["UJobsID"].ToString() != "")
                                        {
                                            defectResponsible.UJobsID = Convert.ToInt32(r["UJobsID"]);
                                        }
                                        if (r["SJobsID"].ToString() != "")
                                        {
                                            defectResponsible.SJobsID = Convert.ToInt32(r["SJobsID"]);
                                        }
                                        defect.PDADefectResponsibles.Add(defectResponsible);
                                    }
                                }
                                //------------------------------

                                //--------漏检员工-------------------
                                DataRow[] drMissedRow = reworkDs.Tables[4].Select("ProductionDefectID=" + reworkDs.Tables[1].Rows[i]["ProductionDefectID"]);
                                if (drMissedRow.Length > Constant.INT_IS_ZERO)
                                {
                                    foreach (DataRow r in drMissedRow)
                                    {
                                        PDADefectMissedResponsibleResult defectMissedResponsible = new PDADefectMissedResponsibleResult();
                                        if (r["ProductionDefectID"].ToString() != "")
                                        {
                                            defectMissedResponsible.ProductionDefectID = Convert.ToInt32(r["ProductionDefectID"]);
                                        }
                                        if (r["StaffID"].ToString() != "")
                                        {
                                            defectMissedResponsible.StaffID = Convert.ToInt32(r["StaffID"]);
                                        }
                                        defectMissedResponsible.StaffCode = r["StaffCode"].ToString();
                                        defectMissedResponsible.StaffName = r["StaffName"].ToString();
                                        if (r["StaffStatus"].ToString() != "")
                                        {
                                            defectMissedResponsible.StaffStatus = Convert.ToInt32(r["StaffStatus"]);
                                        }
                                        if (r["UJobsID"].ToString() != "")
                                        {
                                            defectMissedResponsible.UJobsID = Convert.ToInt32(r["UJobsID"]);
                                        }
                                        if (r["SJobsID"].ToString() != "")
                                        {
                                            defectMissedResponsible.SJobsID = Convert.ToInt32(r["SJobsID"]);
                                        }
                                        defect.PDADefectMissedResponsibles.Add(defectMissedResponsible);
                                    }
                                }
                                //------------------------------
                                DataRow[] drImageRow = reworkDs.Tables[3].Select("ProductionDefectID=" + reworkDs.Tables[1].Rows[row]["ProductionDefectID"]);
                                if (drImageRow.Length > Constant.INT_IS_ZERO)
                                {
                                    foreach (DataRow r in drImageRow)
                                    {
                                        PDADefectImageResult defectImage = new PDADefectImageResult();
                                        if (r["ProductionDefectID"].ToString() != "")
                                        {
                                            defectImage.ProductionDefectID = Convert.ToInt32(r["ProductionDefectID"]);
                                        }
                                        defectImage.Thumbnailpath = r["Thumbnailpath"].ToString();
                                        //if (File.Exists(System.AppDomain.CurrentDomain.BaseDirectory + r["Imagepath"].ToString()))
                                        //{
                                        defectImage.Imagepath = r["Imagepath"].ToString();// r["Imagepath"].ToString();
                                                                                          //}
                                        defect.PDADefectImageResults.Add(defectImage);
                                    }
                                }
                                productionData.PDADefects.Add(defect);
                            }
                            if (productionDatas.PDAProductionData == null)
                            {
                                productionDatas.PDAProductionData = new System.Collections.Generic.List<PDAProductionDataResult>();
                            }
                            productionDatas.PDAProductionData.Add(productionData);
                            //---------------------------------------------------------------------------------
                        }
                    }
                    actionResult.Result = JsonHelper.ToJson(productionDatas);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 编辑后删除生产数据
        /// </summary>
        /// <param name="productionDataID">生产数据ID</param>
        /// <returns>int</returns>
        public ActionResult DeleteProductionDataByID(string accountCode, string userCode, string userPassword, string sessionKey, int productionDataID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int row = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogic.DeleteProductionDataByID(productionDataID));

                actionResult.Result = JsonHelper.ToJson(row);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取产品完成工序的ID
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <returns>int</returns>
        public ActionResult GetCompleteProcedureID(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int row = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogic.GetCompleteProcedureID(barcode));

                actionResult.Result = JsonHelper.ToJson(row);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 绑定图片
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="imagePath">图片路径</param>
        /// <returns></returns>
        public Stream BindDefectImage(string accountCode, string userCode, string userPassword, string sessionKey, string imagePath)
        {
            try
            {
                return ServiceInvoker.Invoke<Stream>(this, () => PDAModuleLogic.BindDefectImage(imagePath));
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                return null;
            }
        }

        /// <summary>
        /// 根据所选工号对应的工种，查出缺陷责任员工
        /// </summary>
        /// <param name="jobs">工种ID</param>
        /// <returns></returns>
        public ActionResult GetDutyStaffByUserJobsID(string accountCode, string userCode, string userPassword, string sessionKey, int jobs, int userid)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetDutyStaffByUserJobsID(jobs, sUserInfo, userid));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #region 产品报废

        /// <summary>
        /// 验证废弃产品唯一性
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <returns>int</returns>
        public ActionResult ScrapProductChack(string accountCode, string userCode, string userPassword, string sessionKey, string barCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                string row = ServiceInvoker.Invoke<string>(this,
                   () => PDAModuleLogic.ScrapProductChack(barCode, sUserInfo));

                string[] rm = row.Split(':');
                actionResult.Result = rm[0];//JsonHelper.ToJson(rm[0]);
                if (rm.Length > 1)
                {
                    actionResult.Message = rm[1];
                }
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 根据条码获取该产品的在产信息以及生产数据
        /// </summary>
        /// <param name="Barcode">产品条码</param>
        /// <returns>装有两个DataTable的数据集，第一个是在产信息，第二个是生产数据</returns>
        public ActionResult GetInProductionAndProductionData(string accountCode, string userCode, string userPassword, string sessionKey, string barCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetInProductionAndProductionData(barCode, sUserInfo));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }


        /// <summary>
        /// 根据工号查询员工档案信息
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="userId"></param>
        /// <returns></returns>
        public ActionResult SearchHrStaffInfo(string accountCode, string userCode, string userPassword, string sessionKey, int userId)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.SearchHrStaffInfo(userId, sUserInfo));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 添加废弃产品记录
        /// </summary>
        /// <param name="SProductEntity">废弃产品实体</param>
        /// <param name="RProcedureEntity">废弃责任工序实体</param>
        /// <param name="SResponsibleList">责任者集合</param>
        /// <param name="userInfo">用户基本信息</param>
        /// <returns>int结果返回值</returns>
        /// <remarks>
        /// 庄天威              2014.09.24              新建
        /// </remarks>
        public ActionResult AddScrapProduct(string accountCode, string userCode, string userPassword, string sessionKey,
            ScrapProductEntity SProductEntity, ResponProcedureEntity RProcedureEntity,
            ScrapResponsibleEntity[] SResponsibleList)
        {
            ActionResult actionResult = new ActionResult();
            if (SResponsibleList == null || SResponsibleList.Length == 0)
            {
                actionResult.Status = (int)Constant.PDAResult.Fail;
                actionResult.Message = "没有选择责任人";
            }
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int addRow = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.AddScrapProduct(SProductEntity, RProcedureEntity, SResponsibleList, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(addRow);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
                // TODO 空指针异常问题检测
                try
                {
                    OutputLog.TraceLog(LogPriority.Error,
                                  this.ToString(),
                                  System.Reflection.MethodBase.GetCurrentMethod().Name,
                                  "accountCode:" + accountCode + "#userCode:" + userCode + "#sessionKey:" + sessionKey,
                                  LocalPath.LogExePath);

                    string json1 = JsonHelper.ToJson(SProductEntity);
                    OutputLog.TraceLog(LogPriority.Error,
                                  this.ToString(),
                                  System.Reflection.MethodBase.GetCurrentMethod().Name,
                                  "SProductEntity:" + json1,
                                  LocalPath.LogExePath);
                    string json2 = JsonHelper.ToJson(RProcedureEntity);
                    OutputLog.TraceLog(LogPriority.Error,
                                  this.ToString(),
                                  System.Reflection.MethodBase.GetCurrentMethod().Name,
                                  "RProcedureEntity:" + json2,
                                  LocalPath.LogExePath);
                    string json3 = JsonHelper.ToJson(SResponsibleList);
                    OutputLog.TraceLog(LogPriority.Error,
                                  this.ToString(),
                                  System.Reflection.MethodBase.GetCurrentMethod().Name,
                                  "SResponsibleList:" + json3,
                                  LocalPath.LogExePath);
                }
                catch (Exception exc)
                {
                    OutputLog.TraceLog(LogPriority.Error,
                                  this.ToString(),
                                  System.Reflection.MethodBase.GetCurrentMethod().Name,
                                  "参数输入异常：" + exc.Message,
                                  LocalPath.LogExePath);
                }
            }
            return actionResult;
        }

        /// <summary>
        /// 获取产品分级的数据（根据ID）
        /// </summary>
        /// <param name="GoodsLevelTypeID">分类类别ID</param>
        /// <param name="GoodsLevelID">分类ID</param>
        /// <param name="sUserInfo">用户基本信息</param>
        /// <returns>DataSet</returns>
        /// <remarks>
        /// 2014.10.22          庄天威         新建
        public ActionResult GetGoodsLevelDataById(string accountCode, string userCode, string userPassword, string sessionKey, int? GoodsLevelTypeID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => SystemModuleLogic.GetGoodsLevelDataById(GoodsLevelTypeID, null, sUserInfo));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取账务日期
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetAccountDate(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DateTime reworkDs = ServiceInvoker.Invoke<DateTime>(this,
                   () => CommonModuleLogic.GetAccountDate(sUserInfo));
                actionResult.Result = JsonHelper.ToJson(reworkDs);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取登陆帐户有无报损权限
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="usercode">工号编码</param>
        /// <returns></returns>
        public ActionResult GetScrapFuntion(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.GetScrapFuntion(userCode, sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #endregion

        /// <summary>
        /// 获取是否存在报损未审核产品
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <returns>int</returns>
        public ActionResult GetScrapProductAuditStatus(string accountCode, string userCode, string userPassword, string sessionKey, string barCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int row = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.GetScrapProductAuditStatus(barCode));

                actionResult.Result = JsonHelper.ToJson(row);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 查询报废产品信息
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="barCode">产品条码</param>
        /// <param name="scrapProductID">报废产品ID</param>
        /// <returns></returns>
        public ActionResult GetScrapProduct(string accountCode, string userCode, string userPassword, string sessionKey, string barCode, int scrapProductID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                ScrapProductEntity selectProEntity = new ScrapProductEntity();
                selectProEntity.BarCode = barCode;
                selectProEntity.ScrapProductID = scrapProductID;
                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetScrapProduct(selectProEntity, sUserInfo));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 根据废弃产品ID获取责任工序
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="scrapProductID">报废产品ID</param>
        /// <returns></returns>
        public ActionResult GetResponProcedureBySPId(string accountCode, string userCode, string userPassword, string sessionKey, int scrapProductID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetResponProcedureBySPId(scrapProductID));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 根据废弃产品ID获取责任人列表
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="scrapProductID">报废产品ID</param>
        /// <returns></returns>
        public ActionResult GetScrapResponsibleBySPId(string accountCode, string userCode, string userPassword, string sessionKey, int scrapProductID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetScrapResponsibleBySPId(scrapProductID));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 添加废弃产品记录
        /// </summary>
        /// <param name="SProductEntity">废弃产品实体</param>
        /// <param name="RProcedureEntity">废弃责任工序实体</param>
        /// <param name="SResponsibleList">责任者集合</param>
        /// <param name="userInfo">用户基本信息</param>
        /// <returns>int结果返回值</returns>
        /// <remarks>
        /// 庄天威              2014.09.24              新建
        /// </remarks>
        public ActionResult UpdateScrapProduct(string accountCode, string userCode, string userPassword, string sessionKey, ScrapProductEntity UpdateSProductEntity,
            ResponProcedureEntity UpdateRProcedureEntity,
            ScrapResponsibleEntity[] UpdateSResponsibleList, ScrapResponsibleEntity[] YSResponsibleList)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int addRow = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.UpdateScrapProduct(UpdateSProductEntity, UpdateRProcedureEntity, UpdateSResponsibleList, YSResponsibleList, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(addRow);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取产品窑炉
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns>Datase</returns>
        public ActionResult GetAllKilntInfo(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetAllKilntInfo(sUserInfo));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取次品产品条码允许编辑
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="barcode">产品条码</param>
        /// <returns>Datase</returns>
        public ActionResult GetSubstandardInfo(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetSubstandardInfo(barcode));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(1);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(0);
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = "次品条码：" + barcode + "不允许修改";
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取产品条码是否重烧
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="barcode">产品条码</param>
        /// <returns>Datase</returns>
        public ActionResult GetReFine(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetReFine(barcode));
                if (reworkDs != null && reworkDs.Tables[0].Rows.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(reworkDs.Tables[0].Rows[0]["IsReFire"]));
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(0);

                }
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取登陆帐户有无成检编辑权限
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="usercode">工号编码</param>
        /// <returns></returns>
        public ActionResult GetFinishedProductEditFuntion(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.GetFinishedProductEditFuntion(sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 根据条码及工序判断是否漏扫
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="usercode">工号编码</param>
        /// <param name="barcode">产品条码</param>
        /// <param name="produceid">工序ID</param>
        /// <returns></returns>
        public ActionResult AddBarCodeMissing(string accountCode, string userCode, string userPassword, string sessionKey, string barcode, int produceid)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                int returnValue = 1;
                //int returnValue = ServiceInvoker.Invoke<int>(this,
                //   () => PMModuleLogicDAL.AddBarCodeMissing(barcode, produceid, sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取登陆帐户有无报损审批权限
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="usercode">工号编码</param>
        /// <returns></returns>
        public ActionResult GetScrapProductFuntion(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.GetScrapProductFuntion(sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取登陆帐户有无报损审批权限
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="usercode">工号编码</param>
        /// <returns></returns>
        public ActionResult GetSpecialRepairflagByBarcode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogic.GetSpecialRepairflagByBarcode(barcode, sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取窑车对应产品列表
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        ///  <param name="KilnCarID">窑车ID</param>
        /// <returns>Dataset</returns>
        public ActionResult GetKilnCarGoodsByKilnCarID(string accountCode, string userCode, string userPassword, string sessionKey, int KilnCarID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetKilnCarGoodsByKilnCarID(KilnCarID));
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(reworkDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 更换条码
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        ///<param name="barcode">原条码</param>
        /// <param name="newBarcode">新条码</param>
        /// <param name="remarks">备注</param>
        /// <returns>操作结果</returns>
        public ActionResult SaveBarCodeChange(string accountCode, string userCode, string userPassword, string sessionKey, string barcode, string newBarcode, string remarks, string groutingUserCode, string goodsCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                ServiceResultEntity serviceResultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.SetFPM0201Data(sUserInfo, barcode, newBarcode, remarks, groutingUserCode, goodsCode));
                if (serviceResultEntity.Status == Constant.ServiceResultStatus.Success)
                {
                    actionResult.Result = 1;
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = serviceResultEntity.Message;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取（注浆登记）的查询数据
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        ///  <param name="se">查询条件</param>
        /// <returns>Dataset</returns>
        public ActionResult GetGroutingList(string accountCode, string userCode, string userPassword, string sessionKey, FPM0202_SE se)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                ServiceResultEntity serviceResultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.GetFPM0202SData(sUserInfo, se));
                if (serviceResultEntity.Status != Constant.ServiceResultStatus.NoSearchResults)
                {
                    // PDA不显示的列删除掉
                    //serviceResultEntity.Data.Tables[0].Columns.Remove("GroutingDailyDetailID");
                    //serviceResultEntity.Data.Tables[0].Columns.Remove("GroutingDailyID");
                    serviceResultEntity.Data.Tables[0].Columns.Remove("GroutingLineName");
                    serviceResultEntity.Data.Tables[0].Columns.Remove("UserCode");
                    serviceResultEntity.Data.Tables[0].Columns.Remove("GoodsName");
                    serviceResultEntity.Data.Tables[0].Columns.Remove("GMouldStatusName");
                    serviceResultEntity.Data.Tables[0].Columns.Remove("GroutingCount");
                    serviceResultEntity.Data.Tables[0].Columns.Remove("Remarks");
                    serviceResultEntity.Data.Tables[0].Columns.Remove("GMouldTypeName");
                    //serviceResultEntity.Data.Tables[0].Columns.Remove("DMUserCode");
                    serviceResultEntity.Data.Tables[0].Columns.Remove("IsPublicBody");
                    actionResult.Result = JsonHelper.ToJson(serviceResultEntity.Data.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = Constant.ServiceResultStatus.NoSearchResults.GetHashCode(); //没有数据  -100
                    actionResult.Message = "无查询数据";
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取（注浆登记）的查询数据
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        ///  <param name="se">查询条件</param>
        /// <returns>Dataset</returns>
        public ActionResult GetGroutingListByBarCode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                ServiceResultEntity serviceResultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.GetFPM0203SData(sUserInfo, barcode));
                if (serviceResultEntity.Status != Constant.ServiceResultStatus.NoSearchResults)
                {
                    actionResult.Result = JsonHelper.ToJson(serviceResultEntity.Data.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = Constant.ServiceResultStatus.NoSearchResults.GetHashCode(); //没有数据  -100
                    actionResult.Message = "无查询数据";
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        ///获得成型线信息
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        ///  <param name="se">查询条件</param>
        /// <returns>Dataset</returns>
        public ActionResult GetGroutingLine(string accountCode, string userCode, string userPassword, string sessionKey, GroutingLineEntity groutingLineEntity)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                DataSet dsReturn = ServiceInvoker.Invoke<DataSet>(this,
                   () => Dongke.IBOSS.PRD.Service.PCModuleLogic.PCModuleLogic.GetGroutingLine(groutingLineEntity, sUserInfo));
                if (dsReturn != null && dsReturn.Tables[0].Rows.Count > 0)
                {
                    actionResult.Result = JsonHelper.ToJson(dsReturn.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = Constant.ServiceResultStatus.NoSearchResults.GetHashCode(); //没有数据  -100
                    actionResult.Message = "无查询数据";
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        ///获取在产产品的信息标识列表
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        ///  <param name="barcode">查询条件</param>
        /// <returns>Dataset</returns>
        public ActionResult GetInProductionDataList(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                DataSet dsReturn = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetInProductionDataList(barcode));
                if (dsReturn != null && dsReturn.Tables[0].Rows.Count > 0)
                {
                    actionResult.Result = JsonHelper.ToJson(dsReturn.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = Constant.ServiceResultStatus.NoSearchResults.GetHashCode(); //没有数据  -100
                    actionResult.Message = "无查询数据";
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        ///获取条码是否注浆登记过，0行无效
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        ///  <param name="barcode">查询条件</param>
        /// <returns>Dataset</returns>
        public ActionResult GetBarCodeInGroutingDailyDetail(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                DataSet dsReturn = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetBarCodeInGroutingDailyDetail(barcode));
                if (dsReturn != null && dsReturn.Tables[0].Rows.Count > 0)
                {
                    actionResult.Result = JsonHelper.ToJson(dsReturn.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = Constant.ServiceResultStatus.NoSearchResults.GetHashCode(); //没有数据  -100
                    actionResult.Message = "该产品条码无效，无法报损!";
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取登陆帐户有变更条码权限
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetBarCodeRecordFuntion(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.GetBarCodeRecordFuntion(sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 成检时获取此条码是否报损 
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="barcode">产品条码</param>
        /// <returns></returns>
        public ActionResult CheckScrapProduct(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogic.CheckScrapProduct(barcode));
                if (returnValue == -100)
                {
                    actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    if (returnValue == 0)
                    {
                        actionResult.Message = "该条码：" + barcode + "存在报损记录(待审批)";
                    }
                    else
                    {
                        actionResult.Message = "该条码：" + barcode + "存在报损记录(审批通过)";
                    }
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取产品完成工序的ID(PDA)
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <returns>int</returns>
        public ActionResult GetCompleteProcedureIDPDA(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetCompleteProcedureIDPDA(barcode));

                actionResult.Result = JsonHelper.ToJson(ds.Tables[0]);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取产品完成工序的ID(PDA)
        /// </summary>
        /// <param name="barcode">产品条码</param>
        /// <returns>int</returns>
        public ActionResult GetGoodsInfoBybarcode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetGoodsInfoBybarcode(barcode));

                actionResult.Result = JsonHelper.ToJson(ds.Tables[0]);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 成检-校验生产工号
        /// </summary>
        /// <param name="usercode">生产工号</param>
        /// <returns>int</returns>
        public ActionResult GetUserCode(string accountCode, string userCode, string userPassword, string sessionKey, string usercode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetUserCode(usercode, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(ds);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 更新漏扫的成型工号
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="groutingUserCode">成型工号</param>
        /// <param name="missingID">漏扫ID</param>
        /// <returns></returns>
        public ActionResult UpdateGroutingUserCodeByMissingID(string accountCode, string userCode, string userPassword, string sessionKey, string groutingUserCode, int missingID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogicDAL.UpdateGroutingUserCodeByMissingID(groutingUserCode, missingID, sUserInfo));
                if (returnValue != -1)
                {
                    actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = "存在无效的漏扫工号";
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 在入窑工序检验窑车号是否存在
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="kilncarcode">窑车编码</param>
        /// <param name="procedureid">工序ID</param>
        /// <returns></returns>
        public ActionResult CheckKilnCarByIntoCar(string accountCode, string userCode, string userPassword, string sessionKey, string kilncarcode, int procedureid)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogicDAL.CheckKilnCarByIntoCar(kilncarcode, procedureid, sUserInfo));
                if (returnValue == 1)
                {
                    actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    if (returnValue == -99)
                        actionResult.Message = "窑炉车号无效";
                    else if (returnValue == -98)
                        actionResult.Message = "窑车己无产品";
                    else if (returnValue == -97)
                        actionResult.Message = "窑车没有入窑,不可以撤销";
                    else if (returnValue == -1)
                        actionResult.Message = "保存失败";
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取盘点单列表
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetInCheckedList(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetInCheckedList(sUserInfo));

                actionResult.Result = JsonHelper.ToJson(ds);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 进行盘点操作
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="InCheckedID">盘点单ID</param>
        /// <param name="BarCode">产品条码</param>
        /// <returns></returns>
        public ActionResult UpdateInChecked(string accountCode, string userCode, string userPassword, string sessionKey, int InCheckedID, string BarCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogicDAL.UpdateInChecked(InCheckedID, BarCode, sUserInfo));
                if (returnValue > 0)
                {
                    actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                    actionResult.Message = "产品" + BarCode + "盘点成功";
                }
                else if (returnValue == 10)
                {
                    actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                    actionResult.Message = "产品" + BarCode + "盘盈成功";
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    if (returnValue == -2)
                        actionResult.Message = "产品" + BarCode + "不是在产产品";
                    //if (returnValue == 10)
                    //    actionResult.Message = "产品" + BarCode + "盘盈成功";
                    //if (returnValue > 0)
                    //    actionResult.Message = "产品" + BarCode + "盘点成功";
                    if (returnValue == -22)
                        actionResult.Message = "产品" + BarCode + "己被其他工号盘点";
                    if (returnValue == -23)
                        actionResult.Message = "产品" + BarCode + "己被其他工号盘盈";
                    if (returnValue == -24)
                        actionResult.Message = "产品" + BarCode + "己被此工号盘点";
                    if (returnValue == -25)
                        actionResult.Message = "产品" + BarCode + "己被此工号盘盈";
                    else if (returnValue == 0)
                        actionResult.Message = "盘点失败";
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #region 班次配置

        /// <summary>
        /// 班次配置-通过工号获取工种列表
        /// </summary>
        /// <param name="userId">工号ID</param>
        /// <returns></returns>
        public ActionResult BindUserJobs(string accountCode, string userCode, string userPassword, string sessionKey, int userId)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => SystemModuleLogic.GetJobByUserId(userId));

                actionResult.Result = JsonHelper.ToJson(ds);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        ///// <summary>
        ///// 班次配置-根据工号查询员工档案信息
        ///// </summary>
        ///// <param name="userId">工号ID</param>
        ///// <returns></returns>
        //public ActionResult SearchHrStaffInfo(string accountCode, string userCode, string userPassword, string sessionKey, int userId)
        //{
        //    ActionResult actionResult = new ActionResult();
        //    try
        //    {
        //        // 验证请求头信息
        //        actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

        //        // 验证失败
        //        if (actionResult.Status != (int)Constant.PDAResult.Success)
        //        {
        //            return actionResult;
        //        }

        //        DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
        //           () => HRModuleLogic.SearchHrStaffInfo(userId,sUserInfo));

        //        actionResult.Result = JsonHelper.ToJson(ds);
        //        actionResult.Status = (int)Constant.PDAResult.Success;
        //    }
        //    catch (Exception ex)
        //    {
        //        //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
        //        OutputLog.TraceLog(LogPriority.Error,
        //                        this.ToString(),
        //                        System.Reflection.MethodBase.GetCurrentMethod().Name,
        //                        ex.ToString(),
        //                        LocalPath.LogExePath);
        //        actionResult.Status = (int)Constant.PDAResult.Exception;
        //        actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
        //    }
        //    return actionResult;
        //}


        /// <summary>
        /// 班次配置-根据员工姓名查员工信息
        /// </summary>
        /// <param name="searchStaffEntity"></param>
        /// <returns></returns>
        public ActionResult SearchStaffInfo(string accountCode, string userCode, string userPassword, string sessionKey, SearchStaffEntity searchStaffEntity)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.SearchStaffInfo(searchStaffEntity, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(ds);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }


        /// <summary>
        /// 获取班次配置信息
        /// </summary>
        /// <param name="searchEntity"></param>
        /// <returns></returns>
        public ActionResult SearchClassesSetting(string accountCode, string userCode, string userPassword, string sessionKey, SearchClassesSettingEntity searchEntity)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                searchEntity.StartAccountDate = Convert.ToDateTime(searchEntity.StartAccountDatePDA);
                searchEntity.EndAccountDate = Convert.ToDateTime(searchEntity.EndAccountDatePDA).AddDays(1).AddMinutes(-1);
                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => PCModuleLogic.SearchClassesSetting(searchEntity, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(ds);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }


        public ActionResult SaveClassesSetting(string accountCode, string userCode, string userPassword, string sessionKey, ClassesSettingEntity setEntity, ClassesDetailSettingEntity[] setDetailEntity)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.SaveClassesSetting(setEntity, setDetailEntity, sUserInfo));
                if (returnValue > 0)
                {
                    actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = "保存失败";
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 班次配置--获取详细信息
        /// </summary>
        /// <param name="searchEntity"></param>
        /// <returns></returns>
        public ActionResult SearchClassesDetail(string accountCode, string userCode, string userPassword, string sessionKey, int classesSettingID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => PCModuleLogic.SearchClassesDetail(classesSettingID, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(ds);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取用户是否有班次配置权限
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetClassesSettingFuntion(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.GetClassesSettingFuntion(sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }


        /// <summary>
        /// 获取盘点单列表
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetAllInChecked(string accountCode, string userCode, string userPassword, string sessionKey, InCheckedEntity entity)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                entity.BeginDate = Convert.ToDateTime(entity.BeginDatePDA);
                entity.EndDate = Convert.ToDateTime(entity.EndDatePDA).AddDays(1);

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetAllInChecked(entity, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(ds);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #endregion

        #region PDA报表

        /// <summary>
        /// 产品质量跟踪
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="se"></param>
        /// <returns></returns>
        public ActionResult GetRPT040104SData(string accountCode, string userCode, string userPassword, string sessionKey, RPT040104_SE se)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                se.CreateTimeStart = Convert.ToDateTime(se.CreateTimeStartPDA);
                se.CreateTimeEnd = Convert.ToDateTime(se.CreateTimeEndPDA).AddDays(1);
                ServiceResultEntity sre = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PDAModuleLogic.GetRPT040104SData(sUserInfo, se));

                if (sre.Status == Constant.ServiceResultStatus.NoSearchResults)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Messages.MSG_CMN_I002;
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(sre.Data);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 工号产量质量分析表
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="se"></param>
        /// <returns></returns>
        public ActionResult GetFP00002Data(string accountCode, string userCode, string userPassword, string sessionKey,
            int rptSProcedureID, string workcode, string date)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                ServiceResultEntity sre = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PDAModuleLogic.GetFP00002Data(sUserInfo, rptSProcedureID, workcode, Convert.ToDateTime(date)));

                if (sre.Status == Constant.ServiceResultStatus.NoSearchResults)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Messages.MSG_CMN_I002;
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(sre.Data);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 工号产量质量分析表(中陶)
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="se"></param>
        /// <returns></returns>
        public ActionResult GetFP00002_1Data(string accountCode, string userCode, string userPassword, string sessionKey,
            int rptSProcedureID, string workcode, string date, string goodscode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                ServiceResultEntity sre = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PDAModuleLogic.GetFP00002_1Data(sUserInfo, rptSProcedureID, workcode,
                                                         Convert.ToDateTime(date), goodscode));

                if (sre.Status == Constant.ServiceResultStatus.NoSearchResults)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Messages.MSG_CMN_I002;
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(sre.Data);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 半检数据统计表
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="se"></param>
        /// <returns></returns>
        public ActionResult GetPDARPT000001Data(string accountCode, string userCode, string userPassword, string sessionKey,
            string workcode, string datebegin, string dateend)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DateTime datetimebegin = Convert.ToDateTime(datebegin);
                DateTime datetimeend = Convert.ToDateTime(dateend);

                datetimebegin = datetimebegin.Date;
                datetimeend = datetimeend.Date.AddDays(1).AddSeconds(-1);

                ServiceResultEntity sre = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PDAModuleLogic.GetPDARPT000001Data(sUserInfo, workcode, datetimebegin, datetimeend));

                if (sre.Status == Constant.ServiceResultStatus.NoSearchResults)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Messages.MSG_CMN_I002;
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(sre.Data);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 工号质量统计表
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="se"></param>
        /// <returns></returns>
        public ActionResult GetPDARPT000002Data(string accountCode, string userCode, string userPassword, string sessionKey,
            int rptSProcedureID, string workcode, string datebegin, string dateend)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DateTime datetimebegin = Convert.ToDateTime(datebegin);
                DateTime datetimeend = Convert.ToDateTime(dateend);

                datetimebegin = datetimebegin.Date;
                datetimeend = datetimeend.Date.AddDays(1).AddSeconds(-1);

                ServiceResultEntity sre = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PDAModuleLogic.GetPDARPT000002Data(sUserInfo, rptSProcedureID, workcode, datetimebegin, datetimeend));

                if (sre.Status == Constant.ServiceResultStatus.NoSearchResults)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Messages.MSG_CMN_I002;
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(sre.Data);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 损坯数据统计表
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="se"></param>
        /// <returns></returns>
        public ActionResult GetPDARPT000003Data(string accountCode, string userCode, string userPassword, string sessionKey,
            string workcode, string datebegin, string dateend)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DateTime datetimebegin = Convert.ToDateTime(datebegin);
                DateTime datetimeend = Convert.ToDateTime(dateend);

                datetimebegin = datetimebegin.Date;
                datetimeend = datetimeend.Date.AddDays(1).AddSeconds(-1);

                ServiceResultEntity sre = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PDAModuleLogic.GetPDARPT000003Data(sUserInfo, workcode, datetimebegin, datetimeend));

                if (sre.Status == Constant.ServiceResultStatus.NoSearchResults)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Messages.MSG_CMN_I002;
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(sre.Data);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }
        #endregion

        /// <summary>
        /// 取得报表数据源数据
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetRptProcedureModule(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                ServiceResultEntity sre = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => ReportModuleLogic.GetRptProcedureModule(sUserInfo));

                if (sre.Status == Constant.ServiceResultStatus.NoSearchResults)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Messages.MSG_CMN_I002;
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(sre.Data);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 取得报表的查询数据源统计工序数据
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="RptProcedureID"></param>
        /// <returns></returns>
        public ActionResult GetRptSourceProcedureModule(string accountCode, string userCode, string userPassword, string sessionKey, int? RptProcedureID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                ServiceResultEntity sre = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => ReportModuleLogic.GetRptSourceProcedureModule(sUserInfo, RptProcedureID));

                if (sre.Status == Constant.ServiceResultStatus.NoSearchResults)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Messages.MSG_CMN_I002;
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(sre.Data);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取用户是否有统计产成品权限
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetStatisticsFinishedProductFuntion(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.GetStatisticsFinishedProductFuntion(sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取用户是否有盘点权限
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetInCheckedFuntion(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.GetInCheckedFuntion(sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 根据条件查询是否存在班次配置
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="userCode">工号编码</param>
        /// <returns></returns>
        public ActionResult GetClassesSetting(string accountCode, string userCode, string userPassword, string sessionKey, string uCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetClassesSetting(uCode, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(ds);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 报损工序查出工号根据生产数据ID
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="ProductionDataID">生产数据ID</param>
        /// <returns></returns>

        public ActionResult GetScrapProductUserCodeByProductionDataID(string accountCode, string userCode, string userPassword, string sessionKey, int ProductionDataID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet dutyProcedureDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetScrapProductUserCodeByProductionDataID(ProductionDataID));
                if (dutyProcedureDs != null && dutyProcedureDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(dutyProcedureDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 在入窑工序检验窑车号是否存在
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="kilncarcode">窑车编码</param>
        /// <param name="procedureid">工序ID</param>
        /// <returns></returns>
        public ActionResult CheckKilnCarByIntoCar2(string accountCode, string userCode, string userPassword, string sessionKey, string kilncarcode, int procedureid)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogicDAL.CheckKilnCarByIntoCar2(kilncarcode, procedureid, sUserInfo));
                if (returnValue == 1)
                {
                    actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    if (returnValue == -99)
                        actionResult.Message = "窑炉车号无效";
                    else if (returnValue == -98)
                        actionResult.Message = "窑车己无产品";
                    else if (returnValue == -97)
                        actionResult.Message = "窑车没有入窑,不可以撤销";
                    else if (returnValue == -1)
                        actionResult.Message = "保存失败";
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 撤销包装
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="barcode"></param>
        /// <returns></returns>
        public ActionResult AddChancelFinishedproduct(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                ServiceResultEntity returnValue = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PMModuleLogicDAL.AddChancelFinishedproduct(barcode, sUserInfo));
                if (Convert.ToInt32(returnValue.Result) > 0)
                {
                    actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    if (Convert.ToInt32(returnValue.Result) == -1)
                        actionResult.Message = "产品条码不存在包装记录";
                    else if (Convert.ToInt32(returnValue.Result) == -200)
                        actionResult.Message = returnValue.Message;
                    else
                        actionResult.Message = "成品撤销失败";
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }
        /*
        /// <summary>
        /// 获取用户是否有撤销包装权限
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetChancelFinishedproductFuntion(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.GetChancelFinishedproductFuntion(sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }
        */
        /// <summary>
        /// 窑车状态明细表查询
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="kilnCarCode"></param>
        /// <returns></returns>
        public ActionResult GetKilnCarStatusDetailByCode(string accountCode, string userCode, string userPassword, string sessionKey, string kilnCarCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                ServiceResultEntity sre = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => ReportModuleLogic.GetKilnCarStatusDetailByCode(kilnCarCode, sUserInfo));

                if (sre.Status == Constant.ServiceResultStatus.NoSearchResults)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Messages.MSG_CMN_I002;
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(sre.Data);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 损坯撤销
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="barcode"></param>
        /// <returns></returns>
        public ActionResult AddCancelScrapProduction(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                ServiceResultEntity returnValue = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PMModuleLogicDAL.AddCancelScrapProduction(barcode, sUserInfo));
                if (Convert.ToInt32(returnValue.Result) > 0)
                {
                    actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    if (Convert.ToInt32(returnValue.Result) == -1)
                        actionResult.Message = "此产品没有损坯，不能撤销";
                    else if (Convert.ToInt32(returnValue.Result) == -200)
                        actionResult.Message = returnValue.Message;
                    else
                        actionResult.Message = "损坯撤销失败";
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /*
        /// <summary>
        /// 获取用户是否有损坯撤销权限
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetCancelScrapProductionFuntion(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.GetCancelScrapProductionFuntion(sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }
        */

        /// <summary>
        /// 获取条码注浆信息
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetGroutingInfoBybarcode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet dutyProcedureDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetGroutingInfoBybarcode(barcode, sUserInfo));
                if (dutyProcedureDs != null && dutyProcedureDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(dutyProcedureDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取条码注浆信息
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetFinishedProductGroutingInfoBybarcode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet dutyProcedureDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetFinishedProductGroutingInfoBybarcode(barcode, sUserInfo));
                if (dutyProcedureDs != null && dutyProcedureDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(dutyProcedureDs.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 公坯设定
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="barcode"></param>
        /// <returns></returns>
        public ActionResult AddPublicBodyProduct(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogicDAL.AddPublicBodyProduct(barcode, sUserInfo));
                if (returnValue > 0)
                {
                    actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    if (returnValue == -1)
                        actionResult.Message = "此产品不在生产线上";
                    else if (returnValue == -2)
                        actionResult.Message = "该产品已经标识为公坯";
                    else
                        actionResult.Message = "公坯设定失败";
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /*
        /// <summary>
        /// 获取用户是否有公坯设定
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetPublicBodyProductFuntion(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.GetPublicBodyProductFuntion(sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }
        */

        /// <summary>
        /// 校验产品条码是否可以走到该工序
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">工序ID</param>
        /// <param name="barcode">条码</param>
        /// <returns></returns>
        /// <remarks>
        /// 陈冰              2014.09.18              新建
        /// </remarks>
        public ActionResult CheckBarcodeDeliverMud(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet barcodeDataSet = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.CheckBarcodeDeliverMud(procedureID, barcode, sUserInfo));

                if (barcodeDataSet != null && barcodeDataSet.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(barcodeDataSet.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取用户所有菜单权限
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetUserAllFunction(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet returnValue = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetUserAllFunction(sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        public ActionResult AddChancelBarCode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                ServiceResultEntity returnValue = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PMModuleLogicDAL.AddChancelBarCode(barcode, sUserInfo));
                if (Convert.ToInt32(returnValue.Result) > 0)
                {
                    actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    if (Convert.ToInt32(returnValue.Result) == -1)
                        actionResult.Message = "无效条码";
                    else if (Convert.ToInt32(returnValue.Result) == -2)
                        actionResult.Message = "已经生产完成";
                    else if (Convert.ToInt32(returnValue.Result) == -3)
                        actionResult.Message = "条码已经申请报废";
                    else if (Convert.ToInt32(returnValue.Result) == -4)
                        actionResult.Message = "此条码当前工序不允许进行撤销";
                    else if (Convert.ToInt32(returnValue.Result) == -5)
                        actionResult.Message = "此条码没有生产数据";
                    else if (Convert.ToInt32(returnValue.Result) == -6)
                        actionResult.Message = "没有当前工序权限";
                    else if (Convert.ToInt32(returnValue.Result) == -7)
                        actionResult.Message = "条码不在生产线上";
                    else if (Convert.ToInt32(returnValue.Result) == -8)
                        actionResult.Message = "操作用户无此工序的撤销范围权限";
                    else if (Convert.ToInt32(returnValue.Result) == -9)
                        actionResult.Message = "条码已经是返工状态";
                    else if (Convert.ToInt32(returnValue.Result) == -200)
                        actionResult.Message = returnValue.Message;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        public ActionResult AddChancelDeliverMudBarCode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                ServiceResultEntity returnValue = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PMModuleLogicDAL.AddChancelDeliverMudBarCode(barcode, sUserInfo));
                if (Convert.ToInt32(returnValue.Result) > 0)
                {
                    actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    if (Convert.ToInt32(returnValue.Result) == -1)
                        actionResult.Message = "无效条码";
                    else if (Convert.ToInt32(returnValue.Result) == -2)
                        actionResult.Message = "已经生产完成";
                    else if (Convert.ToInt32(returnValue.Result) == -3)
                        actionResult.Message = "条码已经申请报废";
                    else if (Convert.ToInt32(returnValue.Result) == -4)
                        actionResult.Message = "此条码当前工序不允许进行撤销";
                    else if (Convert.ToInt32(returnValue.Result) == -5)
                        actionResult.Message = "此条码没有生产数据";
                    else if (Convert.ToInt32(returnValue.Result) == -55)
                        actionResult.Message = "条码已经不在交坯工序，不允许撤销";
                    else if (Convert.ToInt32(returnValue.Result) == -6)
                        actionResult.Message = "没有任何影响行";
                    else if (Convert.ToInt32(returnValue.Result) == -7)
                        actionResult.Message = "条码不在生产线上";
                    else if (Convert.ToInt32(returnValue.Result) == -8)
                        actionResult.Message = "条码已经是返工状态";
                    else if (Convert.ToInt32(returnValue.Result) == -200)
                        actionResult.Message = returnValue.Message;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        public ActionResult GetAllLogoInfo(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet returnValue = ServiceInvoker.Invoke<DataSet>(this,
                   //() => SystemModuleLogic.GetAllLogoInfo(sUserInfo));
                   () => SystemModuleLogic.GetLogoInfo(sUserInfo));
                if (returnValue != null && returnValue.Tables[0].Rows.Count > 0)
                {
                    //DataView dv = returnValue.Tables[0].DefaultView;
                    //dv.RowFilter = "ValueFlag=1";
                    //actionResult.Result = JsonHelper.ToJson(dv.ToTable());
                    actionResult.Result = JsonHelper.ToJson(returnValue.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }
        /// <summary>
        /// 变更产品商标用
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="goodsid"></param>
        /// <returns></returns>
        public ActionResult GetLogoInfoForChange(string accountCode, string userCode, string userPassword, string sessionKey
            , int goodsid)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet returnValue = ServiceInvoker.Invoke<DataSet>(this,
                   //() => SystemModuleLogic.GetAllLogoInfo(sUserInfo));
                   //() => SystemModuleLogic.GetLogoInfo(sUserInfo));
                   () => SystemModuleLogic.GetLogoInfoForChange(sUserInfo, goodsid));
                if (returnValue != null && returnValue.Tables[0].Rows.Count > 0)
                {
                    //DataView dv = returnValue.Tables[0].DefaultView;
                    //dv.RowFilter = "ValueFlag=1";
                    //actionResult.Result = JsonHelper.ToJson(dv.ToTable());
                    actionResult.Result = JsonHelper.ToJson(returnValue.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        public ActionResult GetLogoID(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogic.GetLogoID(procedureID, sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        public ActionResult SaveBarCodeLogo(string accountCode, string userCode, string userPassword, string sessionKey, string barcode, int logoid)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                string returnMessage = "";
                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogicDAL.SaveBarCodeLogo(barcode, logoid, sUserInfo, out returnMessage));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                if (returnValue > 0)
                {
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else if (returnValue == -2)
                {
                    //lsq 20210723 已注浆非产成品没有商标可以变更商标
                    //begin
                    //actionResult.Message = "条码不存在";
                    actionResult.Message = "该条码未注浆";
                    //end
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                }
                else if (returnValue == -3)
                {
                    actionResult.Message = "已交接的产品不能变更商标";
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                }
                else
                {
                    actionResult.Message = returnMessage;
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }


        public ActionResult SaveBarCodeLogoAndGlazetype(string accountCode, string userCode, string userPassword, string sessionKey,
            string barcode, int logoid, int glazetypeid)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                string returnMessage = "";
                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogicDAL.SaveBarCodeLogoAndGlazetype(barcode, logoid, glazetypeid, sUserInfo, out returnMessage));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                if (returnValue > 0)
                {
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = returnMessage;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        public ActionResult SaveBarCodesLogoAndGlazetype(string accountCode, string userCode, string userPassword, string sessionKey,
            string barcodes, int logoid, int glazetypeid, int procedureID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                string returnMessage = "";
                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogicDAL.SaveBarCodesLogoAndGlazetype(barcodes, logoid, glazetypeid, procedureID, sUserInfo, out returnMessage));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                if (returnValue > 0)
                {
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = returnMessage;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }


        public ActionResult GetBarCodeLogoID(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet returnValue = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetBarCodeLogoID(barcode, sUserInfo));
                if (returnValue != null && returnValue.Tables[0].Rows.Count > 0)
                {
                    string err_msg = returnValue.Tables[0].Rows[0]["err_msg"] + "";
                    if (!string.IsNullOrWhiteSpace(err_msg))
                    {
                        actionResult.Status = (int)Constant.PDAResult.Fail;
                        actionResult.Message = err_msg;
                    }
                    else
                    {
                        actionResult.Result = JsonHelper.ToJson(returnValue.Tables[0]);
                        actionResult.Status = (int)Constant.PDAResult.Success;
                    }
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 半检时,入窑前检验获取此条码是否报损为废品
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="barcode">产品条码</param>
        /// <returns></returns>
        public ActionResult CheckWasteScrapProduct(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogic.CheckWasteScrapProduct(barcode));
                if (returnValue != -100)
                {
                    actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = "条码[" + barcode + "]不是废品，不能进行编辑";
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取登陆帐户有无入窑前检验数据编辑权限
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="usercode">工号编码</param>
        /// <returns></returns>
        public ActionResult GetIntoKilnCheckEditFuntion(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.GetIntoKilnCheckEditFuntion(sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取登陆帐户有无半检验数据编辑权限
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="usercode">工号编码</param>
        /// <returns></returns>
        public ActionResult GetNormalCheckEditFuntion(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PDAModuleLogic.GetNormalCheckEditFuntion(sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取缺陷扣罚管理的全部数据
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetAllDefectFine(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => SystemModuleLogic.GetAllDefectFine(sUserInfo));

                if (ds != null && ds.Tables[0].Rows.Count > 0)
                {
                    DataView dv = ds.Tables[0].DefaultView;
                    dv.RowFilter = "valueflag=1";
                    actionResult.Result = JsonHelper.ToJson(dv.ToTable());
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(ds.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }


            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取缺陷扣除数管理的全部数据
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetAllDefectDeduction(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => SystemModuleLogic.GetAllDefectDeduction(sUserInfo));

                if (ds != null && ds.Tables[0].Rows.Count > 0)
                {
                    DataView dv = ds.Tables[0].DefaultView;
                    dv.RowFilter = "valueflag=1";
                    actionResult.Result = JsonHelper.ToJson(dv.ToTable());
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(ds.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }


            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取缺陷扣罚关系管理的全部数据
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetAllDefectFineRelation(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => SystemModuleLogic.GetAllDefectFineRelation(sUserInfo));

                DataTable dt = new DataTable();
                dt.Columns.Add("DefectID");
                dt.Columns.Add("DefectFineID");

                DataView dv = ds.Tables[0].DefaultView;
                DataTable dtFor = dv.ToTable("defectid", true);

                for (int i = 0; i < dtFor.Rows.Count; i++)
                {
                    DataRow[] r = ds.Tables[0].Select("defectid=" + dtFor.Rows[i]["defectid"]);
                    string substring = "";
                    foreach (DataRow r1 in r)
                    {
                        substring += r1["DefectFineID"].ToString() + "-" + r1["DEFECTFINECODE"].ToString() + ",";

                    }
                    if (substring != "")
                    {
                        DataRow drnew = dt.NewRow();
                        drnew["DefectID"] = dtFor.Rows[i]["defectid"];
                        drnew["DefectFineID"] = substring.TrimEnd(',');
                        dt.Rows.Add(drnew);
                    }
                }


                actionResult.Result = JsonHelper.ToJson(dt);//ds.Tables[0]
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取缺陷扣除数关系管理的全部数据
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetAllDefectDeductionRelation(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => SystemModuleLogic.GetAllDefectDeductionRelation(sUserInfo));

                DataTable dt = new DataTable();
                dt.Columns.Add("DefectID");
                dt.Columns.Add("DefectDeductionNum");

                DataView dv = ds.Tables[0].DefaultView;
                DataTable dtFor = dv.ToTable("defectid", true);

                for (int i = 0; i < dtFor.Rows.Count; i++)
                {
                    DataRow[] r = ds.Tables[0].Select("defectid=" + dtFor.Rows[i]["defectid"]);
                    string substring = "";
                    foreach (DataRow r1 in r)
                    {
                        substring += r1["DefectDeductionID"].ToString() + "-" + r1["DefectDeductionNum"].ToString() + ",";

                    }
                    if (substring != "")
                    {
                        DataRow drnew = dt.NewRow();
                        drnew["DefectID"] = dtFor.Rows[i]["defectid"];
                        drnew["DefectDeductionNum"] = substring.TrimEnd(',');
                        dt.Rows.Add(drnew);
                    }
                }


                actionResult.Result = JsonHelper.ToJson(dt);//ds.Tables[0]
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取盘点单明细
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetUpdateInCheckedInfo(string accountCode, string userCode, string userPassword, string sessionKey, string incheckedno)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetUpdateInCheckedInfo(incheckedno, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(ds);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 半检检验条码
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult SemiCheckBarcode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                ServiceResultEntity resultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PMModuleLogic.SemiCheckBarcode(barcode, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                if (Convert.ToInt32(resultEntity.Result) < 0)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                actionResult.Message = resultEntity.Message;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 根据条码获取经过的工序,用于绑定返工工序
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetSemiCheckPassProcedure(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet resultEntity = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetSemiCheckPassProcedure(barcode));

                actionResult.Result = JsonHelper.ToJson(resultEntity);

                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取登陆帐户有无半检状态权限
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetSemiCheckStatusFuntion(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int resultEntity = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogic.GetSemiCheckStatusFuntion(sUserInfo));

                actionResult.Result = JsonHelper.ToJson(resultEntity);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 复检状态数据源
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetSemiCheckType(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet resultEntity = ServiceInvoker.Invoke<DataSet>(this,
                   () => SystemModuleLogic.GetSemiCheckType());

                actionResult.Result = JsonHelper.ToJson(resultEntity.Tables[0]);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 根据半成品检验数据ID,显示半成品数据信息
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetSemiCheckByID(string accountCode, string userCode, string userPassword, string sessionKey, int semiCheckID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet reworkDs = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetSemiCheckByID(semiCheckID));

                SemiCheckEntity[] productionDatas = new SemiCheckEntity[1];
                if (reworkDs != null && reworkDs.Tables.Count > Constant.INT_IS_ZERO)
                {
                    if (reworkDs != null && reworkDs.Tables[0].Rows.Count > Constant.INT_IS_ZERO)
                    {
                        for (int i = 0; i < reworkDs.Tables[0].Rows.Count; i++)
                        {
                            SemiCheckEntity productionData = new SemiCheckEntity();
                            productionData.BarCode = reworkDs.Tables[0].Rows[i]["BarCode"].ToString();
                            if (reworkDs.Tables[0].Rows[i]["GoodsID"].ToString() != "")
                            {
                                productionData.GoodsID = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["GoodsID"].ToString());
                            }
                            productionData.SemiCheckID = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["SemiCheckID"].ToString());
                            productionData.GoodsCode = reworkDs.Tables[0].Rows[i]["GoodsCode"].ToString();
                            productionData.GoodsName = reworkDs.Tables[0].Rows[i]["GoodsName"].ToString();
                            productionData.SemiCheckType = reworkDs.Tables[0].Rows[i]["SemiCheckType"].ToString();
                            productionData.ReFine = 0;
                            if (reworkDs.Tables[0].Rows[i]["ReworkProcedureID"].ToString() != "")
                            {
                                productionData.ReworkProcedureID = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["ReworkProcedureID"].ToString());
                            }
                            productionData.ReSemiCheckType = reworkDs.Tables[0].Rows[i]["ReSemiCheckType"].ToString();
                            productionData.ReworkProcedureCode = reworkDs.Tables[0].Rows[i]["ReworkProcedureCode"].ToString();
                            productionData.ReworkProcedureName = reworkDs.Tables[0].Rows[i]["ReworkProcedureName"].ToString();
                            productionData.Remarks = reworkDs.Tables[0].Rows[i]["Remarks"].ToString();
                            if (reworkDs.Tables[0].Rows[i]["UserID"].ToString() != "")
                            {
                                productionData.SemiCheckUserID = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["UserID"].ToString());
                                productionData.SemiCheckUserCode = reworkDs.Tables[0].Rows[i]["UserCode"].ToString();
                            }
                            if (reworkDs.Tables[0].Rows[i]["GoodsLevelTypeID"].ToString() != "")
                            {
                                productionData.GoodsLevelTypeID = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["GoodsLevelTypeID"].ToString());
                            }
                            //productionData.UserCode = reworkDs.Tables[0].Rows[i]["UserCode"].ToString();
                            //productionData.UserName = reworkDs.Tables[0].Rows[i]["UserName"].ToString();
                            productionData.SpecialRepairFlag = reworkDs.Tables[0].Rows[i]["SpecialRepairFlag"].ToString();
                            productionData.GroutingUserCode = reworkDs.Tables[0].Rows[i]["GroutingUserCode"].ToString();
                            productionData.GroutingNum = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["GroutingNum"]);
                            productionData.IsPublicBody = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["IsPublicBody"]);
                            productionData.MouldCode = reworkDs.Tables[0].Rows[i]["MouldCode"].ToString();
                            productionData.GroutingDate = Convert.ToDateTime(reworkDs.Tables[0].Rows[i]["GroutingDate"]);

                            if (reworkDs.Tables[0].Rows[i]["ReworkUserID"].ToString() != "")
                            {
                                productionData.ReworkUserID = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["ReworkUserID"].ToString());
                                productionData.ReworkUserCode = reworkDs.Tables[0].Rows[i]["ReworkUserCode"].ToString();
                            }
                            productionData.ReSemiCheckUserCode = reworkDs.Tables[0].Rows[i]["ReSemiCheckUserCode"].ToString();
                            if (reworkDs.Tables[0].Rows[i]["logoid"].ToString() != "")
                            {
                                productionData.Logoid = Convert.ToInt32(reworkDs.Tables[0].Rows[i]["Logoid"]);
                                productionData.LogoCode = reworkDs.Tables[0].Rows[i]["LogoCode"].ToString();
                                productionData.LogoName = reworkDs.Tables[0].Rows[i]["LogoName"].ToString();
                            }
                            productionData.SemiCheckTime = Convert.ToDateTime(reworkDs.Tables[0].Rows[i]["SemiCheckTime"]);
                            if (reworkDs.Tables[0].Rows[i]["ReSemiCheckTime"] != DBNull.Value)
                            {
                                productionData.ReSemiCheckDateTimeStart = Convert.ToDateTime(reworkDs.Tables[0].Rows[i]["ReSemiCheckTime"]);
                            }
                            DataView dvDefect = reworkDs.Tables[1].DefaultView;
                            dvDefect.RowFilter = "SemiCheckID=" + reworkDs.Tables[0].Rows[i]["SemiCheckID"].ToString();
                            DataTable dtDefect = dvDefect.ToTable();
                            for (int row = 0; row < dtDefect.Rows.Count; row++)
                            {
                                // 产品缺陷
                                SemiCheckDefectEntity defect = new SemiCheckDefectEntity();
                                //defect.SpecialDefect = dtDefect.Rows[row]["SpecialDefect"].ToString();
                                //defect.DefectDeductionNum = Convert.ToDecimal(dtDefect.Rows[row]["DefectDeductionNum"].ToString());
                                //if (dtDefect.Rows[row]["ProductionDefectID"].ToString() != "")
                                //{
                                //    defect.ProductionDefectID = Convert.ToInt32(dtDefect.Rows[row]["ProductionDefectID"].ToString());
                                //}
                                //defect.BarCode = dtDefect.Rows[row]["BarCode"].ToString();
                                if (dtDefect.Rows[row]["DefectID"].ToString() != "")
                                {
                                    defect.DefectID = Convert.ToInt32(dtDefect.Rows[row]["DefectID"].ToString());
                                }
                                defect.DefectName = dtDefect.Rows[row]["DefectName"].ToString();
                                defect.DefectCode = dtDefect.Rows[row]["DefectCode"].ToString();
                                if (dtDefect.Rows[row]["DefectPositionID"].ToString() != "")
                                {
                                    defect.DefectPositionID = Convert.ToInt32(dtDefect.Rows[row]["DefectPositionID"].ToString());
                                }
                                defect.DefectPositionName = dtDefect.Rows[row]["DefectPositionName"].ToString();
                                defect.DefectPositionCode = dtDefect.Rows[row]["DefectPositionCode"].ToString();
                                if (dtDefect.Rows[row]["DefectProcedureID"].ToString() != "")
                                {
                                    defect.DefectProcedureID = Convert.ToInt32(dtDefect.Rows[row]["DefectProcedureID"].ToString());
                                }
                                defect.DefectProcedureName = dtDefect.Rows[row]["DefectProcedureName"].ToString();
                                defect.DefectProcedureCode = dtDefect.Rows[row]["DefectProcedureCode"].ToString();
                                if (dtDefect.Rows[row]["DefectUserID"].ToString() != "")
                                {
                                    defect.DefectUserID = Convert.ToInt32(dtDefect.Rows[row]["DefectUserID"].ToString());
                                }
                                defect.DefectUserName = dtDefect.Rows[row]["DefectUserName"].ToString();
                                defect.DefectUserCode = dtDefect.Rows[row]["DefectUserCode"].ToString();
                                //if (dtDefect.Rows[row]["Jobs"].ToString() != "")
                                //{
                                //    defect.Jobs = Convert.ToInt32(dtDefect.Rows[row]["Jobs"].ToString());
                                //}
                                //if (dtDefect.Rows[row]["MissedUserID"].ToString() != "")
                                //{
                                //    defect.MissedUserID = Convert.ToInt32(dtDefect.Rows[row]["MissedUserID"].ToString());
                                //}
                                //defect.MissedUserCode = dtDefect.Rows[row]["MissedUserCode"].ToString();
                                //defect.MissedUserName = dtDefect.Rows[row]["MissedUserName"].ToString();
                                //defect.JobsText = dtDefect.Rows[row]["JobsText"].ToString();
                                defect.Remarks = dtDefect.Rows[row]["remarks"].ToString();
                                if (dtDefect.Rows[row]["semicheckid"].ToString() != "")
                                {
                                    defect.SemiCheckID = Convert.ToInt32(dtDefect.Rows[row]["semicheckid"].ToString());
                                }

                                if (dtDefect.Rows[row]["DefectProductionDataID"].ToString() != "")
                                {
                                    defect.DefectProductionDataID = Convert.ToInt32(dtDefect.Rows[row]["DefectProductionDataID"].ToString());
                                }

                                //if (dtDefect.Rows[row]["DefectFineID"].ToString() != "")
                                //{
                                //    defect.DefectFineID = Convert.ToInt32(dtDefect.Rows[row]["DefectFineID"].ToString());
                                //}
                                //defect.DefectFineValue = dtDefect.Rows[row]["DefectFineValue"].ToString();

                                //--------责任员工-------------------
                                DataRow[] drRow = reworkDs.Tables[2].Select("SemiCheckDefectID=" + reworkDs.Tables[1].Rows[row]["SemiCheckDefectID"]);
                                if (drRow.Length > Constant.INT_IS_ZERO)
                                {
                                    if (defect.DefectResponsibles == null)
                                    {
                                        defect.DefectResponsibles = new List<SemiCheckResponsibleEntity>();
                                    }
                                    foreach (DataRow r in drRow)
                                    {
                                        SemiCheckResponsibleEntity defectResponsible = new SemiCheckResponsibleEntity();
                                        if (r["SemiCheckDefectID"].ToString() != "")
                                        {
                                            defectResponsible.SemiCheckDefectID = Convert.ToInt32(r["SemiCheckDefectID"]);
                                        }
                                        if (r["StaffID"].ToString() != "")
                                        {
                                            defectResponsible.StaffID = Convert.ToInt32(r["StaffID"]);
                                        }
                                        defectResponsible.StaffCode = r["StaffCode"].ToString();
                                        defectResponsible.StaffName = r["StaffName"].ToString();
                                        if (r["StaffStatus"].ToString() != "")
                                        {
                                            defectResponsible.StaffStatus = Convert.ToInt32(r["StaffStatus"]);
                                        }
                                        if (r["UJobsID"].ToString() != "")
                                        {
                                            defectResponsible.UJobsID = Convert.ToInt32(r["UJobsID"]);
                                        }
                                        if (r["SJobsID"].ToString() != "")
                                        {
                                            defectResponsible.SJobsID = Convert.ToInt32(r["SJobsID"]);
                                        }

                                        defect.DefectResponsibles.Add(defectResponsible);
                                    }
                                }
                                //------------------------------
                                if (productionData.SemiCheckDefects == null)
                                {
                                    productionData.SemiCheckDefects = new List<SemiCheckDefectEntity>();
                                }
                                productionData.SemiCheckDefects.Add(defect);
                            }
                            //if (productionDatas.PDAProductionData == null)
                            //{
                            //    productionDatas.PDAProductionData = new System.Collections.Generic.List<PDAProductionDataResult>();
                            //}
                            productionDatas[0] = productionData;
                            //---------------------------------------------------------------------------------
                        }

                    }
                }


                actionResult.Result = JsonHelper.ToJson(productionDatas);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 保存半检登记
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="entity">半检实体类</param>
        /// <param name="sUserInfo">用户基本信息</param>
        /// <returns></returns>
        public ActionResult AddSemiCheck(string accountCode, string userCode, string userPassword, string sessionKey, SemiCheckEntity[] entityobj)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                ServiceResultEntity resultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                    () => PMModuleLogicDAL.AddSemiCheck(entityobj, sUserInfo));
                string err = string.Empty;
                err = resultEntity.Message;
                if (err == null)
                {
                    err = "";
                }

                SemiCheckEntity entity = entityobj[0];
                if (entity.SemiCheckCategory == 1) // 半检登记
                {
                }
                else if (entity.SemiCheckCategory == 2)// 复检登记
                {
                    err = JsonHelper.ToJson(err);
                }
                else if (entity.SemiCheckCategory == 3)// 撤销复检
                {
                    err = JsonHelper.ToJson(err);
                }
                //actionResult.Result = JsonHelper.ToJson(err);
                actionResult.Result = err;//JsonHelper.ToJson(err);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 根据所选工号，查出缺陷责任员工
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetSemiCheckDefectStaffByUserID(string accountCode, string userCode, string userPassword, string sessionKey, int userid)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet resultEntity = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetSemiCheckDefectStaffByUserID(sUserInfo, userid));

                actionResult.Result = JsonHelper.ToJson(resultEntity.Tables[0]);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取半成品缺陷管理的全部数据
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetAllSemicheckDefect(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet resultEntity = ServiceInvoker.Invoke<DataSet>(this,
                   () => SystemModuleLogic.GetAllSemicheckDefect(sUserInfo));

                actionResult.Result = JsonHelper.ToJson(resultEntity.Tables[0]);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取PLC参数
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetPLCParameter(string accountCode, string userCode, string userPassword, string sessionKey,string PlcName)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet resultEntity = ServiceInvoker.Invoke<DataSet>(this,
                   () => SystemModuleLogic.GetPLCParameter(PlcName));

                actionResult.Result = JsonHelper.ToJson(resultEntity.Tables[0]);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取产品信息
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetGodsParameter(string accountCode, string userCode, string userPassword, string sessionKey, string BarCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet resultEntity = ServiceInvoker.Invoke<DataSet>(this,
                   () => SystemModuleLogic.GetGodsParameter(BarCode));

                actionResult.Result = JsonHelper.ToJson(resultEntity.Tables[0]);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 传输PLC产品信息
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult AddPlcGood(string accountCode, string userCode, string userPassword, string sessionKey,string Plcid, string BarCode,string GROUTINGLINECODE, string GOODSMODEL, string GOODSTYPENAME, string GOODSSPECIFICATION)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                ServiceResultEntity resultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
				   () => SystemModuleLogic.AddPlcGood(Plcid, BarCode, GROUTINGLINECODE, GOODSMODEL, GOODSTYPENAME, GOODSSPECIFICATION));

                actionResult.Result = JsonHelper.ToJson(resultEntity);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取半成品缺陷位置管理的全部数据
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetAllScdefectPosition(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet resultEntity = ServiceInvoker.Invoke<DataSet>(this,
                   () => SystemModuleLogic.GetAllScdefectPosition(sUserInfo));

                actionResult.Result = JsonHelper.ToJson(resultEntity.Tables[0]);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 复检验条码
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult ReSemiCheckBarcode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                ServiceResultEntity resultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PMModuleLogic.ReSemiCheckBarcode(barcode, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                if (Convert.ToInt32(resultEntity.Result) < 0)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                actionResult.Message = resultEntity.Message;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 撤销复检验条码
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult CancelSemiCheckBarcode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                ServiceResultEntity resultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PMModuleLogic.CancelSemiCheckBarcode(barcode, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                if (Convert.ToInt32(resultEntity.Result) < 0)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                actionResult.Message = resultEntity.Message;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 恢复数据
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult ResetBarCode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int resultEntity = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogicDAL.ResetBarCode(barcode));

                if (resultEntity > 0)
                {
                    actionResult.Status = (int)Constant.PDAResult.Success;
                    actionResult.Message = "恢复数据成功";
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    if (resultEntity == -1)
                    {
                        actionResult.Message = "此条码没有清除，不能恢复";
                    }
                    else if (resultEntity == 0)
                    {
                        actionResult.Message = "没有可恢复的数据";
                    }
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 通过SettingCode获取系统参数管理的数据
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="settingcode">设置编码</param>
        /// <returns></returns>
        public ActionResult GetSystemSettingDataByCode(string accountCode, string userCode, string userPassword, string sessionKey, string settingcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet resultEntity = ServiceInvoker.Invoke<DataSet>(this,
                   () => SystemModuleLogic.GetSystemSettingDataByCode(settingcode, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(resultEntity.Tables[0]);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 校验条码是否允许撤销，如果不允许提示错误消息
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="orgTime">原时间</param>
        /// <param name="days">允许撤销天数</param>
        /// <param name="settingCode">设置code,用于返回不同错误消息</param>
        /// <returns></returns>
        public ActionResult BarcodeAllowCancel(string accountCode, string userCode, string userPassword, string sessionKey, string orgTime, int days, string settingCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                string[] subOrgTime = orgTime.Split('-');
                DateTime newOrgTime = new DateTime(Convert.ToInt32(subOrgTime[0]), Convert.ToInt32(subOrgTime[1]), Convert.ToInt32(subOrgTime[2]));
                ServiceResultEntity resultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PMModuleLogic.BarcodeAllowCancel(newOrgTime, days, settingCode, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                if (Convert.ToInt32(resultEntity.Result) < 0)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                actionResult.Message = resultEntity.Message;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取生产订单管理的全部数据
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetOrderList(string accountCode, string userCode, string userPassword, string sessionKey, OrderEntity order)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet resultEntity = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.GetOrderList(order, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(resultEntity.Tables[0]);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        public ActionResult FinishedHandoverBarcode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                ServiceResultEntity resultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PMModuleLogic.FinishedHandoverBarcode(barcode, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                if (Convert.ToInt32(resultEntity.Result) < 0)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Result = resultEntity.OtherStatus; //漏扫1,反之0
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(resultEntity.Data);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                actionResult.Message = resultEntity.Message;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        public ActionResult GetSystemData(string accountCode, string userCode, string userPassword, string sessionKey)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet resultEntity = ServiceInvoker.Invoke<DataSet>(this,
                   () => SystemModuleLogic.GetSystemData(sUserInfo));

                actionResult.Result = JsonHelper.ToJson(resultEntity.Tables[0]);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        public ActionResult SaveFinishedHandover(string accountCode, string userCode, string userPassword, string sessionKey, int orderid, OrderEntity[] orderEntity)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                DataTable dtOrderData = DataConvert.ObjectConvertToTable<OrderEntity>(orderEntity);
                ServiceResultEntity resultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PMModuleLogicDAL.SaveFinishedHandover(orderid, dtOrderData, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                if (Convert.ToInt32(resultEntity.Result) < 0)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                actionResult.Message = resultEntity.Message;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        public ActionResult CancelFinishedHandoverBarcode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                ServiceResultEntity resultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PMModuleLogic.CancelFinishedHandoverBarcode(barcode, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                if (Convert.ToInt32(resultEntity.Result) < 0)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                }
                else
                {
                    actionResult.Result = JsonHelper.ToJson(resultEntity.Data.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                actionResult.Message = resultEntity.Message;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        public ActionResult SaveCancelFinishedHandoverByBarcode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                ServiceResultEntity resultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PMModuleLogicDAL.SaveCancelFinishedHandoverByBarcode(barcode, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                if (Convert.ToInt32(resultEntity.Result) < 0)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                actionResult.Message = resultEntity.Message;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        public ActionResult SaveChangeFinishedHandoverByBarcode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode, int orderid)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                ServiceResultEntity resultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PMModuleLogicDAL.SaveChangeFinishedHandoverByBarcode(barcode, orderid, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                if (Convert.ToInt32(resultEntity.Result) < 0)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                actionResult.Message = resultEntity.Message;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #region PDA条码打印
        /// <summary>
        /// 获取条码打印机
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetBarcodePrinter(string accountCode, string userCode, string userPassword, string sessionKey, int printType = 0)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet resultEntity = BarcodePrintLogic.GetBarcodePrinter(sUserInfo, printType);

                actionResult.Result = JsonHelper.ToJson(resultEntity.Tables[0]);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 打印条码样式（补打）
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult PrintBarcodeLayout(string accountCode, string userCode, string userPassword, string sessionKey,
            string barcode, int copies, int printerID, int printWay = 2)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                //ServiceResultEntity sre = BarcodePrintLogic.PrintBarcode(barcode,
                //                       copies, printerID, sUserInfo);
                ServiceResultEntity sre = BarcodePrintLogic.PrintBarcode_3C(barcode,
                           copies, printerID, sUserInfo, printWay);
                if (sre.Status != Constant.ServiceResultStatus.Success)
                {
                    actionResult.Status = (int)Constant.ServiceResultStatus.Other;
                    actionResult.Message = sre.Message;
                    return actionResult;
                }

                actionResult.Result = JsonHelper.ToJson(sre.Result as DataTable);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #endregion PDA条码打印

        #region 统计报表
        /// <summary>
        /// 成型结算报表
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <returns></returns>
        public ActionResult GetGroutingSettlementInfo(string accountCode, string userCode, string userPassword, string sessionKey,
            int currentMonth)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DateTime date = DateTime.Now;
                if (currentMonth != 1)
                {
                    date = date.AddMonths(-1);
                }

                ServiceResultEntity resultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => PublicModuleLogic.GetFP00002Data(sUserInfo.AccountID, userCode, date));

                if (resultEntity == null || resultEntity.Data == null)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = "查询失败";
                    return actionResult;
                }

                if (resultEntity.Status == Constant.ServiceResultStatus.Other)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = resultEntity.Message;
                    return actionResult;
                }

                actionResult.Result = JsonHelper.ToJson(resultEntity.Data.Tables["DataM"]);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #endregion

        #region 设置当期用户默认打印机配置
        /// <summary>
        /// 设置当期用户默认打印机配置
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="printerID"></param>
        /// <returns></returns>
        public ActionResult SetCurrentUserPrinter(string accountCode, string userCode, string userPassword, string sessionKey,
            int printerID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                ServiceResultEntity resultEntity = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => BarcodePrintLogic.SetCurrentUserPrinter(printerID, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                if (resultEntity.Status == Constant.ServiceResultStatus.Other || Convert.ToInt32(resultEntity.Result) < 0)
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                actionResult.Message = resultEntity.Message;
            }
            catch (Exception ex)
            {
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }


        /// <summary>
        /// 校验产品条码是否可以进行回收
        /// </summary>
        /// <param name="accountCode">帐套code</param>
        /// <param name="userCode">用户code</param>
        /// <param name="userPassword">用户密码</param>
        /// <param name="sessionKey">本次登陆密钥</param>
        /// <param name="procedureID">工序ID</param>
        /// <param name="barcode">条码</param>
        /// <returns></returns>
        /// <remarks>
        /// 王鑫              2017.7.21             新建
        /// </remarks>
        public ActionResult CheckRecydingFlagBarcode(string accountCode, string userCode, string userPassword, string sessionKey, int procedureID, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet barcodeDataSet = ServiceInvoker.Invoke<DataSet>(this,
                   () => PMModuleLogic.CheckRecydingFlagBarcode(procedureID, barcode, sUserInfo));

                if (barcodeDataSet != null && barcodeDataSet.Tables.Count > Constant.INT_IS_ZERO)
                {
                    actionResult.Result = JsonHelper.ToJson(barcodeDataSet.Tables[0]);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                }
                else
                {
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = Constant.PDA_RESULT_UNKNOWN_ERR;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }


        /// <summary>
        /// 获取回收标识
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="usercode">工号编码</param>
        /// <returns></returns>
        public ActionResult GetRecyclingflagByBarcode(string accountCode, string userCode, string userPassword, string sessionKey, string barcode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                int returnValue = ServiceInvoker.Invoke<int>(this,
                   () => PMModuleLogic.GetRecyclingflagByBarcode(barcode, sUserInfo));
                actionResult.Result = JsonHelper.ToJson(returnValue);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }


        #endregion

        #region 注浆盘点

        /// <summary>
        /// 获取注浆盘点单列表
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetAllGBChecked(string accountCode, string userCode, string userPassword, string sessionKey, InCheckedEntity entity)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                entity.BeginDate = Convert.ToDateTime(entity.BeginDatePDA);
                entity.EndDate = Convert.ToDateTime(entity.EndDatePDA).AddDays(1);

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetAllGBChecked(entity, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(ds);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                string json = JsonHelper.ToJson(entity);
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name + "\r\n" + json,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 进行盘点操作
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="InCheckedID">盘点单ID</param>
        /// <param name="BarCode">产品条码</param>
        /// <returns></returns>
        public ActionResult UpdateGBChecked(string accountCode, string userCode, string userPassword, string sessionKey, int CheckedID, string BarCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                ClientRequestEntity cre = new ClientRequestEntity();
                cre.Properties["CheckedID"] = CheckedID;
                cre.Properties["Barcode"] = BarCode;
                ServiceResultEntity returnValue = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.UpdateGBChecked(sUserInfo, cre));

                if (returnValue.Status == Constant.ServiceResultStatus.Success)
                {
                    //actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                    actionResult.Message = "产品【" + BarCode + "】盘点成功";
                }
                else
                {
                    //actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = returnValue.Message;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取盘点单明细
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetUpdateGBCheckedInfo(string accountCode, string userCode, string userPassword, string sessionKey, int checkedID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.
                       GetUpdateGBCheckedInfo(checkedID, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(ds);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }
        #endregion

        #region 模具盘点

        /// <summary>
        /// 获取模具盘点单列表
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetAllMouldChecked(string accountCode, string userCode, string userPassword, string sessionKey, InCheckedEntity entity)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }
                entity.BeginDate = Convert.ToDateTime(entity.BeginDatePDA);
                entity.EndDate = Convert.ToDateTime(entity.EndDatePDA).AddDays(1);

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => PDAModuleLogic.GetAllMouldChecked(entity, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(ds);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 进行盘点操作
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="InCheckedID">盘点单ID</param>
        /// <param name="BarCode">产品条码</param>
        /// <returns></returns>
        public ActionResult UpdateMouldChecked(string accountCode, string userCode, string userPassword, string sessionKey, int CheckedID, string BarCode)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                ClientRequestEntity cre = new ClientRequestEntity();
                cre.Properties["CheckedID"] = CheckedID;
                cre.Properties["Barcode"] = BarCode;
                ServiceResultEntity returnValue = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                   () => Dongke.IBOSS.PRD.Service.PCModuleService.PCModuleLogic.UpdateMouldChecked(sUserInfo, cre));

                if (returnValue.Status == Constant.ServiceResultStatus.Success)
                {
                    //actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Success;
                    actionResult.Message = "产品【" + BarCode + "】盘点成功";
                }
                else
                {
                    //actionResult.Result = JsonHelper.ToJson(returnValue);
                    actionResult.Status = (int)Constant.PDAResult.Fail;
                    actionResult.Message = returnValue.Message;
                }
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        /// <summary>
        /// 获取盘点单明细
        /// </summary>
        /// <param name="sUserInfo"></param>
        /// <returns></returns>
        public ActionResult GetUpdateMouldCheckedInfo(string accountCode, string userCode, string userPassword, string sessionKey, int checkedID)
        {
            ActionResult actionResult = new ActionResult();
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                DataSet ds = ServiceInvoker.Invoke<DataSet>(this,
                   () => Dongke.IBOSS.PRD.Service.PCModuleService.PCModuleLogic.
                       GetUpdateMouldCheckedInfo(checkedID, sUserInfo));

                actionResult.Result = JsonHelper.ToJson(ds);
                actionResult.Status = (int)Constant.PDAResult.Success;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }
        #endregion

        #region 通用接口

        /// <summary>
        /// PDA调用通用接口
        /// </summary>
        /// <param name="accountCode"></param>
        /// <param name="userCode"></param>
        /// <param name="userPassword"></param>
        /// <param name="sessionKey"></param>
        /// <param name="module"></param>
        /// <param name="action"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public ActionResult DoAction(string accountCode, string userCode, string userPassword, string sessionKey,
            string module, string action, string jsonData)
        {
            ActionResult actionResult = null;
            try
            {
                // 验证请求头信息
                actionResult = this.DoPDACheck(accountCode, userCode, userPassword, sessionKey);

                // 验证失败
                if (actionResult.Status != (int)Constant.PDAResult.Success)
                {
                    return actionResult;
                }

                actionResult.Status = (int)Constant.PDAResult.Fail;

                Dictionary<string, object> data = null;
                if (!string.IsNullOrEmpty(jsonData) && jsonData[0] == '{')
                {
                    data = JsonHelper.FromJson<Dictionary<string, object>>(jsonData);
                }

                #region PDA报表
                if (module == "Report")
                {
                    // 成型月度结算
                    if (action == "GetGroutingSettlementInfo")
                    {
                        DateTime month = DateTime.Now;
                        month = new DateTime(month.Year, month.Month, 1);
                        //month = new DateTime(2017, 6, 1);
                        int currentMonth = Convert.ToInt32(data["CurrentMonth"]);
                        if (currentMonth != 1)
                        {
                            month = month.AddMonths(-1);
                        }

                        ServiceResultEntity sre = PDAModuleLogic.GetGroutingSettlementInfo(sUserInfo, month);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }

                        return actionResult;
                    }
                    // 成型月度结算-明细
                    if (action == "GetGroutingSettlementDetail")
                    {
                        DateTime month = DateTime.Now;
                        month = new DateTime(month.Year, month.Month, 1);
                        //month = new DateTime(2017, 6, 1);
                        int currentMonth = Convert.ToInt32(data["CurrentMonth"]);
                        if (currentMonth != 1)
                        {
                            month = month.AddMonths(-1);
                        }

                        string goodsCode = data["GoodsCode"].ToString();
                        string detailDate = data["DetailDate"].ToString();
                        DateTime? date = null;
                        if (detailDate != "合计")
                        {
                            date = DateTime.Parse(detailDate);
                        }

                        ServiceResultEntity sre = PDAModuleLogic.GetGroutingSettlementDetail(sUserInfo, month, goodsCode, date);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }

                        return actionResult;
                    }
                    // 产成品交接汇总
                    if (action == "GetFinishedProductHandoverSum")
                    {
                        DateTime date = DateTime.Parse(data["date"].ToString());

                        ServiceResultEntity sre = ReportModuleLogic.GetRPT0030112NPDAData(date,
                            data["goodscode"] as string, sUserInfo);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data);
                        }
                        else if (sre.Status == Constant.ServiceResultStatus.NoSearchResults)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }

                        return actionResult;
                    }

                    //xuwei add 2019-10-21
                    //统计当前工号，当日,按产品编码分组统计半检返修数据数量
                    if (action == "GetSemiReworkDayCount")
                    {
                        //不指定参数查询当天
                        string dateStr = DateTime.Now.ToString("yyyy-MM-dd");

                        //dateStr = "2019-10-17";
                        //指定参数查询特定日期
                        if (data.ContainsKey("SemiReworkDate")) dateStr = data["SemiReworkDate"].ToString();


                        ServiceResultEntity sre = ReportModuleLogic.GetSemiReworkDayCount(sUserInfo, dateStr);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                    //xuwe end

                    return actionResult;
                }
                #endregion

                #region 模具管理
                if (module == "PC_Mould")
                {
                    #region 模具新建画面数据初始化
                    if (action == "GetMouldAddInit")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["MouldID"] = 0;
                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PCModuleService.PCModuleLogic.GetFPC1002LoadData(sUserInfo, cre);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                    #endregion
                    #region 验证模具产品型号
                    if (action == "CheckGoodsCodeOnMould")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["GoodsCode"] = data["GoodsCode"];
                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PCModuleService.PCModuleLogic.GetFPC1002GoodsData(sUserInfo, cre);
                        if (sre.Status == Constant.ServiceResultStatus.Success &&
                            sre.Data.Tables[0].Rows.Count > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "无效产品型号";
                        }
                        return actionResult;
                    }
                    #endregion
                    #region 验证模具生产工号
                    if (action == "CheckUserCodeOnMould")
                    {
                        DataTable sre = PDAModuleLogic.GetUserCodeOnMould(sUserInfo, data["UserCode"].ToString());

                        if (sre != null && sre.Rows.Count > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "无效生产工号";
                        }
                        return actionResult;
                    }
                    #endregion
                    #region 新建保存
                    if (action == "SetMouldAdd" || action == "SetMouldEdit")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        foreach (string item in data.Keys)
                        {
                            if (item == "ProductionDate")
                            {
                                cre.Properties.Add(item, Convert.ToDateTime(data[item]));
                            }
                            else
                            {
                                cre.Properties.Add(item, data[item]);
                            }
                        }
                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PCModuleService.PCModuleLogic.SetFPC1002Data(sUserInfo, cre);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = sre.OtherStatus;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                    #endregion
                    #region 模具编辑画面数据初始化
                    if (action == "GetMouldEditInfo")
                    {
                        DataTable sre = PDAModuleLogic.GetMouldEditInfo(sUserInfo, data["MouldBarcode"].ToString());

                        if (sre != null && sre.Rows.Count > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "无效模具条码";
                        }
                        return actionResult;
                    }
                    #endregion
                    #region 模具操作-画面初始化
                    if (action == "GetMouldOperationInit")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["MouldOperationType"] = data["MouldOperationType"];
                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PCModuleService.PCModuleLogic.GetFPC1004LoadData(sUserInfo, cre);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = sre.OtherStatus;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                    #endregion
                    #region 模具操作-验证模具条码
                    if (action == "CheckMouldBarcode")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["MouldBarcode"] = data["MouldBarcode"];
                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PCModuleService.PCModuleLogic.GetMouldData(sUserInfo, cre);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            if (sre.Data.Tables[0].Rows.Count == 0)
                            {
                                actionResult.Status = (int)Constant.PDAResult.Fail;
                                actionResult.Result = -1;
                                actionResult.Message = "模具【" + data["MouldBarcode"] + "】不存在";
                                return actionResult;
                            }
                            int mouldOperationType = Convert.ToInt32(data["MouldOperationType"]);
                            int mouldStatusID = Convert.ToInt32(sre.Data.Tables[0].Rows[0]["MouldStatus"]);
                            string mouldStatusName = sre.Data.Tables[0].Rows[0]["MouldStatusName"].ToString();
                            #region 报损
                            if (mouldOperationType == 2)
                            {
                                if (mouldStatusID == 1 || mouldStatusID == 3)
                                {
                                    actionResult.Status = (int)Constant.PDAResult.Success;
                                    actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                                }
                                else
                                {
                                    actionResult.Status = (int)Constant.PDAResult.Fail;
                                    actionResult.Result = -2;
                                    actionResult.Message = "模具【" + data["MouldBarcode"] + "】当前状态为【" + mouldStatusName + "】，不能进行报损操作";
                                }
                                return actionResult;
                            }
                            #endregion
                            #region 撤销
                            if (mouldOperationType == 3)
                            {
                                if (mouldStatusID == 4)
                                {
                                    actionResult.Status = (int)Constant.PDAResult.Success;
                                    actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                                }
                                else
                                {
                                    actionResult.Status = (int)Constant.PDAResult.Fail;
                                    actionResult.Result = -2;
                                    actionResult.Message = "模具【" + data["MouldBarcode"] + "】当前状态为【" + mouldStatusName + "】，不能进行撤销报损操作";
                                }
                                return actionResult;
                            }
                            #endregion
                            #region 领用
                            if (mouldOperationType == 4)
                            {
                                if (mouldStatusID == 1)
                                {
                                    actionResult.Status = (int)Constant.PDAResult.Success;
                                    actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                                }
                                else
                                {
                                    actionResult.Status = (int)Constant.PDAResult.Fail;
                                    actionResult.Result = -2;
                                    actionResult.Message = "模具【" + data["MouldBarcode"] + "】当前状态为【" + mouldStatusName + "】，不能进行领用操作";
                                }
                                return actionResult;
                            }
                            #endregion
                            #region 回收
                            if (mouldOperationType == 5)
                            {
                                if (mouldStatusID == 3)
                                {
                                    actionResult.Status = (int)Constant.PDAResult.Success;
                                    actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                                }
                                else
                                {
                                    actionResult.Status = (int)Constant.PDAResult.Fail;
                                    actionResult.Result = -2;
                                    actionResult.Message = "模具【" + data["MouldBarcode"] + "】当前状态为【" + mouldStatusName + "】，不能进行回收操作";
                                }
                                return actionResult;
                            }
                            #endregion
                            #region 变更型号
                            if (mouldOperationType == -1)
                            {
                                if (mouldStatusID != 4)
                                {
                                    actionResult.Status = (int)Constant.PDAResult.Success;
                                    actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                                }
                                else
                                {
                                    actionResult.Status = (int)Constant.PDAResult.Fail;
                                    actionResult.Result = -2;
                                    actionResult.Message = "模具【" + data["MouldBarcode"] + "】当前状态为【" + mouldStatusName + "】，不能进行变更型号操作";
                                }
                                return actionResult;
                            }
                            #endregion
                            #region 替换条码
                            if (mouldOperationType == -2)
                            {
                                actionResult.Status = (int)Constant.PDAResult.Success;
                                actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                                return actionResult;
                            }
                            #endregion
                            return actionResult;
                        }
                    }
                    #endregion
                    #region 模具操作-保存
                    if (action == "SetMouldOperation")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["MouldIDs"] = string.Join(",", JsonHelper.FromJson<int[]>(data["MouldIDs"].ToString()));
                        cre.Properties["MouldOperationType"] = data["MouldOperationType"];
                        cre.Properties["Remarks"] = data["Remarks"];

                        int mouldOperationType = Convert.ToInt32(data["MouldOperationType"]);
                        if (mouldOperationType == (int)Constant.MouldOperationType.ChangeGoodsCode)
                        {
                            cre.Properties["GoodsID"] = data["GoodsID"];
                            cre.Properties["GoodsCode"] = data["GoodsCode"];
                        }
                        else if (mouldOperationType == (int)Constant.MouldOperationType.InvToScrap)
                        {
                            cre.Properties["ScrapReason"] = data["ScrapReason"];
                            cre.Properties["ScrapResponsibility"] = data["ScrapRemarks"];
                        }

                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PCModuleService.PCModuleLogic.SetFPC1004Data(sUserInfo, cre);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                        }

                        return actionResult;
                    }
                    #endregion
                    #region 模具操作-替换条码
                    if (action == "ChangedMouldBarcode")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["MouldID"] = data["MouldID"];
                        cre.Properties["MouldBarcode"] = data["MouldBarcode"];
                        cre.Properties["NewMouldBarcode"] = data["NewMouldBarcode"];
                        cre.Properties["Remarks"] = data["Remarks"];

                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PCModuleService.PCModuleLogic.SetFPC1003Data(sUserInfo, cre);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = sre.OtherStatus;
                            actionResult.Message = sre.Message;
                        }

                        return actionResult;
                    }
                    #endregion
                    #region 模具跟踪表
                    if (action == "GetMoldTracking")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["MouldBarcode"] = data["MouldBarcode"];

                        ServiceResultEntity sre = ReportModuleLogic.GetRPT020105Data(cre, sUserInfo);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "此模具条码不存在";
                        }

                        return actionResult;
                    }
                    #endregion
                    return actionResult;
                }
                #endregion

                #region 成型线模具管理
                if (module == "PC_GroutingLineMould")
                {
                    #region 获取当前用户成型线模具管理权限
                    if (action == "GetGMouldStatusRight")
                    {
                        DataTable right = PDAModuleLogic.GetGMouldStatusRight(sUserInfo);
                        actionResult.Status = (int)Constant.PDAResult.Success;
                        if (right != null && right.Rows.Count > 0)
                        {
                            actionResult.Result = JsonHelper.ToJson(right);
                        }
                        return actionResult;
                    }
                    #endregion
                    #region 获取成型线状态等信息，和成型模具信息
                    if (action == "GetGroutingLineMould")
                    {
                        int? groutingLineID = null;
                        string groutingLineCode = null;
                        if (data.ContainsKey("GroutingLineID"))
                        {
                            groutingLineID = Convert.ToInt32(data["GroutingLineID"]);
                        }
                        else
                        {
                            groutingLineCode = data["GroutingLineCode"] + "";
                        }
                        DataSet lineInfo = PDAModuleLogic.GetGroutingLineMould(sUserInfo, groutingLineCode, groutingLineID);
                        if (lineInfo == null)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "成型线【" + groutingLineCode + "】不存在或是停用状态";
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(lineInfo);
                        }
                        return actionResult;
                    }
                    #endregion
                    #region 模具操作-画面初始化
                    if (action == "GetMouldOperationInit")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["MouldOperationType"] = 2;
                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PCModuleService.PCModuleLogic.GetFPC1004LoadData(sUserInfo, cre);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = sre.OtherStatus;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                    #endregion
                    #region 成型模具操作-画面初始化
                    if (action == "GetGroutingMouldOperationInit")
                    {
                        DataTable initData = PDAModuleLogic.GetGroutingMouldOperationInit(sUserInfo, 6);
                        if (initData != null && initData.Rows.Count > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            Dictionary<string, string> syssetting = new Dictionary<string, string>();
                            foreach (DataRow item in initData.Rows)
                            {
                                syssetting.Add(item["settingcode"].ToString(), item["settingvalue"].ToString());
                            }
                            actionResult.Result = JsonHelper.ToJson(syssetting);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                        }
                        return actionResult;
                    }
                    #endregion
                    #region 模具操作-验证模具条码
                    if (action == "CheckMouldBarcode")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["MouldBarcode"] = data["MouldBarcode"];
                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PCModuleService.PCModuleLogic.GetMouldData(sUserInfo, cre);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            if (sre.Data.Tables[0].Rows.Count == 0)
                            {
                                actionResult.Status = (int)Constant.PDAResult.Fail;
                                actionResult.Result = -1;
                                actionResult.Message = "模具【" + data["MouldBarcode"] + "】不存在";
                                return actionResult;
                            }
                            int mouldOperationType = Convert.ToInt32(data["MouldOperationType"]);
                            int mouldStatusID = Convert.ToInt32(sre.Data.Tables[0].Rows[0]["MouldStatus"]);
                            string mouldStatusName = sre.Data.Tables[0].Rows[0]["MouldStatusName"].ToString();
                            #region 上线
                            if (mouldOperationType == 6)
                            {
                                if (mouldStatusID == 1 || mouldStatusID == 3)
                                {
                                    if (data.ContainsKey("GoodsID"))
                                    {
                                        if (sre.Data.Tables[0].Rows[0]["GoodsID"] + "" != data["GoodsID"] + "")
                                        {
                                            actionResult.Status = (int)Constant.PDAResult.Fail;
                                            actionResult.Result = -3;
                                            actionResult.Message =
                                                "模具【" + data["MouldBarcode"] + "】的产品型号为【" +
                                                sre.Data.Tables[0].Rows[0]["GoodsCode"] +
                                                "】与当前不一致";
                                            return actionResult;
                                        }
                                    }
                                    actionResult.Status = (int)Constant.PDAResult.Success;
                                    actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                                }
                                else
                                {
                                    actionResult.Status = (int)Constant.PDAResult.Fail;
                                    actionResult.Result = -2;
                                    actionResult.Message = "模具【" + data["MouldBarcode"] + "】当前状态为【" + mouldStatusName + "】，不能进行报损操作";
                                }
                                return actionResult;
                            }
                            #endregion
                            return actionResult;
                        }
                    }
                    #endregion
                    #region 停用
                    if (action == "StopGroutingLineDetail")
                    {
                        if (data == null || !data.ContainsKey("Details"))
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "参数错误";
                            return actionResult;
                        }
                        Dictionary<string, object>[] details = JsonHelper.FromJson<Dictionary<string, object>[]>(data["Details"].ToString());

                        DataTable gTable = new DataTable();
                        gTable.Columns.Add("GroutingLineID", typeof(int));
                        gTable.Columns.Add("GroutingLineCode");
                        gTable.Columns.Add("LineOPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("GroutingLineDetailID", typeof(int));
                        gTable.Columns.Add("GroutingMouldCode");
                        gTable.Columns.Add("RecordRemarks");
                        gTable.Columns.Add("OPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("MouldID", typeof(int));
                        gTable.Columns.Add("MouldCode");

                        int groutingLineID = Convert.ToInt32(data["GroutingLineID"]);
                        string groutingLineCode = data["GroutingLineCode"] + "";
                        DateTime lineOPTimeStamp = Convert.ToDateTime(data["LineOPTimeStamp"]);

                        foreach (Dictionary<string, object> item in details)
                        {
                            int? mouldID = null;
                            if (item.ContainsKey("MouldID"))
                            {
                                mouldID = Convert.ToInt32(item["MouldID"]);
                                if (mouldID == 0)
                                {
                                    mouldID = null;
                                }
                            }
                            gTable.Rows.Add(groutingLineID, groutingLineCode, lineOPTimeStamp,
                                item["GLineDetailID"], item["GLineDetailCode"],
                                item["RecordRemarks"], Convert.ToDateTime(item["OPTimeStamp"]),
                                mouldID, item["MouldCode"]);
                        }

                        int result = PCModuleLogicDAL.StopGroutingLineDetail(gTable, sUserInfo);

                        if (result > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = result;
                            actionResult.Message = "成型线状态已被更改，请刷新成型线数据";
                            return actionResult;
                        }

                        return actionResult;
                    }
                    #endregion
                    #region 启用
                    if (action == "StartGroutingLineDetail")
                    {
                        if (data == null || !data.ContainsKey("Details"))
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "参数错误";
                            return actionResult;
                        }
                        Dictionary<string, object>[] details = JsonHelper.FromJson<Dictionary<string, object>[]>(data["Details"].ToString());

                        DataTable gTable = new DataTable();
                        gTable.Columns.Add("GroutingLineID", typeof(int));
                        gTable.Columns.Add("GroutingLineCode");
                        gTable.Columns.Add("LineOPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("GroutingLineDetailID", typeof(int));
                        gTable.Columns.Add("GroutingMouldCode");
                        gTable.Columns.Add("RecordRemarks");
                        gTable.Columns.Add("OPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("MouldID", typeof(int));
                        gTable.Columns.Add("MouldCode");

                        int groutingLineID = Convert.ToInt32(data["GroutingLineID"]);
                        string groutingLineCode = data["GroutingLineCode"] + "";
                        DateTime lineOPTimeStamp = Convert.ToDateTime(data["LineOPTimeStamp"]);

                        foreach (Dictionary<string, object> item in details)
                        {
                            int? mouldID = null;
                            if (item.ContainsKey("MouldID"))
                            {
                                mouldID = Convert.ToInt32(item["MouldID"]);
                                if (mouldID == 0)
                                {
                                    mouldID = null;
                                }
                            }
                            gTable.Rows.Add(groutingLineID, groutingLineCode, lineOPTimeStamp,
                                item["GLineDetailID"], item["GLineDetailCode"],
                                item["RecordRemarks"], Convert.ToDateTime(item["OPTimeStamp"]),
                                mouldID, item["MouldCode"]);
                        }

                        int result = PCModuleLogicDAL.StartGroutingLineDetail(gTable, sUserInfo);

                        if (result > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = result;
                            actionResult.Message = "成型线状态已被更改，请刷新成型线数据";
                            return actionResult;
                        }

                        return actionResult;
                    }
                    #endregion
                    #region 维修
                    if (action == "RepairStartGroutingLineDetail")
                    {
                        if (data == null || !data.ContainsKey("Details"))
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "参数错误";
                            return actionResult;
                        }
                        Dictionary<string, object>[] details = JsonHelper.FromJson<Dictionary<string, object>[]>(data["Details"].ToString());

                        DataTable gTable = new DataTable();
                        gTable.Columns.Add("GroutingLineID", typeof(int));
                        gTable.Columns.Add("GroutingLineCode");
                        gTable.Columns.Add("LineOPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("GroutingLineDetailID", typeof(int));
                        gTable.Columns.Add("GroutingMouldCode");
                        gTable.Columns.Add("RecordRemarks");
                        gTable.Columns.Add("OPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("MouldID", typeof(int));
                        gTable.Columns.Add("MouldCode");

                        int groutingLineID = Convert.ToInt32(data["GroutingLineID"]);
                        string groutingLineCode = data["GroutingLineCode"] + "";
                        DateTime lineOPTimeStamp = Convert.ToDateTime(data["LineOPTimeStamp"]);

                        foreach (Dictionary<string, object> item in details)
                        {
                            int? mouldID = null;
                            if (item.ContainsKey("MouldID"))
                            {
                                mouldID = Convert.ToInt32(item["MouldID"]);
                                if (mouldID == 0)
                                {
                                    mouldID = null;
                                }
                            }
                            gTable.Rows.Add(groutingLineID, groutingLineCode, lineOPTimeStamp,
                                item["GLineDetailID"], item["GLineDetailCode"],
                                item["RecordRemarks"], Convert.ToDateTime(item["OPTimeStamp"]),
                                mouldID, item["MouldCode"]);
                        }

                        int result = PCModuleLogicDAL.RepairStartGroutingLineDetail(gTable, sUserInfo);

                        if (result > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = result;
                            actionResult.Message = "成型线状态已被更改，请刷新成型线数据";
                            return actionResult;
                        }

                        return actionResult;
                    }
                    #endregion
                    #region 结束维修
                    if (action == "RepairEndGroutingLineDetail")
                    {
                        if (data == null || !data.ContainsKey("Details"))
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "参数错误";
                            return actionResult;
                        }
                        Dictionary<string, object>[] details = JsonHelper.FromJson<Dictionary<string, object>[]>(data["Details"].ToString());

                        DataTable gTable = new DataTable();
                        gTable.Columns.Add("GroutingLineID", typeof(int));
                        gTable.Columns.Add("GroutingLineCode");
                        gTable.Columns.Add("LineOPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("GroutingLineDetailID", typeof(int));
                        gTable.Columns.Add("GroutingMouldCode");
                        gTable.Columns.Add("RecordRemarks");
                        gTable.Columns.Add("OPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("MouldID", typeof(int));
                        gTable.Columns.Add("MouldCode");

                        int groutingLineID = Convert.ToInt32(data["GroutingLineID"]);
                        string groutingLineCode = data["GroutingLineCode"] + "";
                        DateTime lineOPTimeStamp = Convert.ToDateTime(data["LineOPTimeStamp"]);

                        foreach (Dictionary<string, object> item in details)
                        {
                            int? mouldID = null;
                            if (item.ContainsKey("MouldID"))
                            {
                                mouldID = Convert.ToInt32(item["MouldID"]);
                                if (mouldID == 0)
                                {
                                    mouldID = null;
                                }
                            }
                            gTable.Rows.Add(groutingLineID, groutingLineCode, lineOPTimeStamp,
                                item["GLineDetailID"], item["GLineDetailCode"],
                                item["RecordRemarks"], Convert.ToDateTime(item["OPTimeStamp"]),
                                mouldID, item["MouldCode"]);
                        }

                        int result = PCModuleLogicDAL.RepairEndGroutingLineDetail(gTable, sUserInfo);

                        if (result > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = result;
                            actionResult.Message = "成型线状态已被更改，请刷新成型线数据";
                            return actionResult;
                        }

                        return actionResult;
                    }
                    #endregion
                    #region 换模
                    if (action == "ChangeGMouldStartGroutingLineDetail")
                    {
                        if (data == null || !data.ContainsKey("Details"))
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "参数错误";
                            return actionResult;
                        }
                        Dictionary<string, object>[] details = JsonHelper.FromJson<Dictionary<string, object>[]>(data["Details"].ToString());

                        DataTable gTable = new DataTable();
                        gTable.Columns.Add("GroutingLineID", typeof(int));
                        gTable.Columns.Add("GroutingLineCode");
                        gTable.Columns.Add("LineOPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("GroutingLineDetailID", typeof(int));
                        gTable.Columns.Add("GroutingMouldCode");
                        gTable.Columns.Add("RecordRemarks");
                        gTable.Columns.Add("OPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("MouldID", typeof(int));
                        gTable.Columns.Add("MouldCode");
                        gTable.Columns.Add("MouldOutputNo", typeof(int));
                        gTable.Columns.Add("MouldStatus", typeof(int));
                        gTable.Columns.Add("ScrapReason", typeof(int));
                        gTable.Columns.Add("ScrapResponsibility");

                        int groutingLineID = Convert.ToInt32(data["GroutingLineID"]);
                        string groutingLineCode = data["GroutingLineCode"] + "";
                        DateTime lineOPTimeStamp = Convert.ToDateTime(data["LineOPTimeStamp"]);

                        int mouldStatus = Convert.ToInt32(data["MouldStatus"]);
                        int scrapReason = Convert.ToInt32(data["ScrapReason"]);
                        string scrapResponsibility = data["ScrapRemarks"] + "";

                        foreach (Dictionary<string, object> item in details)
                        {
                            int? mouldID = null;
                            if (item.ContainsKey("MouldID"))
                            {
                                mouldID = Convert.ToInt32(item["MouldID"]);
                                if (mouldID == 0)
                                {
                                    mouldID = null;
                                }
                            }
                            gTable.Rows.Add(groutingLineID, groutingLineCode, lineOPTimeStamp,
                                item["GLineDetailID"], item["GLineDetailCode"],
                                item["RecordRemarks"], Convert.ToDateTime(item["OPTimeStamp"]),
                                mouldID, item["MouldCode"], item["MouldOutputNo"], mouldStatus,
                                (scrapReason <= 0 ? null : (object)scrapReason), scrapResponsibility);
                        }

                        int result = PCModuleLogicDAL.ChangeGMouldStartGroutingLineDetail(gTable, sUserInfo);

                        if (result > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = result;
                            actionResult.Message = "成型线状态已被更改，请刷新成型线数据";
                            return actionResult;
                        }

                        return actionResult;
                    }
                    #endregion
                    #region 变产
                    if (action == "UpdateLineStartGroutingLineDetail")
                    {
                        if (data == null || !data.ContainsKey("Details"))
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "参数错误";
                            return actionResult;
                        }
                        Dictionary<string, object>[] details = JsonHelper.FromJson<Dictionary<string, object>[]>(data["Details"].ToString());

                        DataTable gTable = new DataTable();
                        gTable.Columns.Add("GroutingLineID", typeof(int));
                        gTable.Columns.Add("GroutingLineCode");
                        gTable.Columns.Add("LineOPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("GroutingLineDetailID", typeof(int));
                        gTable.Columns.Add("GroutingMouldCode");
                        gTable.Columns.Add("RecordRemarks");
                        gTable.Columns.Add("OPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("MouldID", typeof(int));
                        gTable.Columns.Add("MouldCode");
                        gTable.Columns.Add("MouldOutputNo", typeof(int));
                        gTable.Columns.Add("MouldStatus", typeof(int));
                        gTable.Columns.Add("ScrapReason", typeof(int));
                        gTable.Columns.Add("ScrapResponsibility");

                        int groutingLineID = Convert.ToInt32(data["GroutingLineID"]);
                        string groutingLineCode = data["GroutingLineCode"] + "";
                        DateTime lineOPTimeStamp = Convert.ToDateTime(data["LineOPTimeStamp"]);

                        int mouldStatus = Convert.ToInt32(data["MouldStatus"]);
                        int scrapReason = Convert.ToInt32(data["ScrapReason"]);
                        string scrapResponsibility = data["ScrapRemarks"] + "";

                        foreach (Dictionary<string, object> item in details)
                        {
                            int? mouldID = null;
                            if (item.ContainsKey("MouldID"))
                            {
                                mouldID = Convert.ToInt32(item["MouldID"]);
                                if (mouldID == 0)
                                {
                                    mouldID = null;
                                }
                            }
                            gTable.Rows.Add(groutingLineID, groutingLineCode, lineOPTimeStamp,
                                item["GLineDetailID"], item["GLineDetailCode"],
                                item["RecordRemarks"], Convert.ToDateTime(item["OPTimeStamp"]),
                                mouldID, item["MouldCode"], item["MouldOutputNo"], mouldStatus,
                                (scrapReason <= 0 ? null : (object)scrapReason), scrapResponsibility);
                        }

                        int result = PCModuleLogicDAL.UpdateLineStartGroutingLineDetail(gTable, sUserInfo);

                        if (result > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = result;
                            actionResult.Message = "成型线状态已被更改，请刷新成型线数据";
                            return actionResult;
                        }

                        return actionResult;
                    }
                    #endregion
                    #region 整线变产
                    if (action == "UpdateAllLineStartGroutingLineDetail")
                    {
                        if (data == null || !data.ContainsKey("Details"))
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "参数错误";
                            return actionResult;
                        }
                        Dictionary<string, object>[] details = JsonHelper.FromJson<Dictionary<string, object>[]>(data["Details"].ToString());

                        DataTable gTable = new DataTable();
                        gTable.Columns.Add("GroutingLineID", typeof(int));
                        gTable.Columns.Add("GroutingLineCode");
                        gTable.Columns.Add("LineOPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("GroutingLineDetailID", typeof(int));
                        gTable.Columns.Add("GroutingMouldCode");
                        gTable.Columns.Add("RecordRemarks");
                        gTable.Columns.Add("OPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("MouldID", typeof(int));
                        gTable.Columns.Add("MouldCode");
                        gTable.Columns.Add("MouldOutputNo", typeof(int));
                        gTable.Columns.Add("MouldStatus", typeof(int));
                        gTable.Columns.Add("ScrapReason", typeof(int));
                        gTable.Columns.Add("ScrapResponsibility");

                        int groutingLineID = Convert.ToInt32(data["GroutingLineID"]);
                        string groutingLineCode = data["GroutingLineCode"] + "";
                        DateTime lineOPTimeStamp = Convert.ToDateTime(data["LineOPTimeStamp"]);

                        int mouldStatus = Convert.ToInt32(data["MouldStatus"]);
                        int scrapReason = Convert.ToInt32(data["ScrapReason"]);
                        string scrapResponsibility = data["ScrapRemarks"] + "";

                        foreach (Dictionary<string, object> item in details)
                        {
                            int? mouldID = null;
                            if (item.ContainsKey("MouldID"))
                            {
                                mouldID = Convert.ToInt32(item["MouldID"]);
                                if (mouldID == 0)
                                {
                                    mouldID = null;
                                }
                            }
                            gTable.Rows.Add(groutingLineID, groutingLineCode, lineOPTimeStamp,
                                item["GLineDetailID"], item["GLineDetailCode"],
                                item["RecordRemarks"], Convert.ToDateTime(item["OPTimeStamp"]),
                                mouldID, item["MouldCode"], item["MouldOutputNo"], mouldStatus,
                                (scrapReason <= 0 ? null : (object)scrapReason), scrapResponsibility);
                        }

                        int result = PCModuleLogicDAL.UpdateAllLineStartGroutingLineDetail(gTable, groutingLineID, lineOPTimeStamp, sUserInfo);

                        if (result > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = result;
                            actionResult.Message = "成型线状态已被更改，请刷新成型线数据";
                            return actionResult;
                        }

                        return actionResult;
                    }
                    #endregion
                    #region 卸模
                    if (action == "UnloadGroutingLineDetail")
                    {
                        if (data == null || !data.ContainsKey("Details"))
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "参数错误";
                            return actionResult;
                        }
                        Dictionary<string, object>[] details = JsonHelper.FromJson<Dictionary<string, object>[]>(data["Details"].ToString());

                        DataTable gTable = new DataTable();
                        gTable.Columns.Add("GroutingLineID", typeof(int));
                        gTable.Columns.Add("GroutingLineCode");
                        gTable.Columns.Add("LineOPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("GroutingLineDetailID", typeof(int));
                        gTable.Columns.Add("GroutingMouldCode");
                        gTable.Columns.Add("RecordRemarks");
                        gTable.Columns.Add("OPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("MouldID", typeof(int));
                        gTable.Columns.Add("MouldCode");
                        gTable.Columns.Add("MouldOutputNo", typeof(int));
                        gTable.Columns.Add("MouldStatus", typeof(int));
                        gTable.Columns.Add("ScrapReason", typeof(int));
                        gTable.Columns.Add("ScrapResponsibility");

                        int groutingLineID = Convert.ToInt32(data["GroutingLineID"]);
                        string groutingLineCode = data["GroutingLineCode"] + "";
                        DateTime lineOPTimeStamp = Convert.ToDateTime(data["LineOPTimeStamp"]);

                        int mouldStatus = Convert.ToInt32(data["MouldStatus"]);
                        int scrapReason = Convert.ToInt32(data["ScrapReason"]);
                        string scrapResponsibility = data["ScrapRemarks"] + "";

                        foreach (Dictionary<string, object> item in details)
                        {
                            int? mouldID = null;
                            if (item.ContainsKey("MouldID"))
                            {
                                mouldID = Convert.ToInt32(item["MouldID"]);
                                if (mouldID == 0)
                                {
                                    mouldID = null;
                                }
                            }
                            gTable.Rows.Add(groutingLineID, groutingLineCode, lineOPTimeStamp,
                                item["GLineDetailID"], item["GLineDetailCode"],
                                item["RecordRemarks"], Convert.ToDateTime(item["OPTimeStamp"]),
                                mouldID, item["MouldCode"], item["MouldOutputNo"], mouldStatus,
                                (scrapReason <= 0 ? null : (object)scrapReason), scrapResponsibility);
                        }

                        int result = PCModuleLogicDAL.UnloadGroutingLineDetail(gTable, sUserInfo);

                        if (result > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = result;
                            actionResult.Message = "成型线状态已被更改，请刷新成型线数据";
                            return actionResult;
                        }

                        return actionResult;
                    }
                    #endregion
                    #region 结束换模
                    if (action == "ChangeGMouldEndGroutingLineDetail")
                    {
                        if (data == null || !data.ContainsKey("Details"))
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "参数错误";
                            return actionResult;
                        }
                        Dictionary<string, object>[] details = JsonHelper.FromJson<Dictionary<string, object>[]>(data["Details"].ToString());

                        DataTable gTable = new DataTable();
                        gTable.Columns.Add("GroutingLineID", typeof(int));
                        gTable.Columns.Add("GroutingLineCode");
                        gTable.Columns.Add("LineOPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("GroutingLineDetailID", typeof(int));
                        gTable.Columns.Add("GroutingMouldCode");
                        gTable.Columns.Add("RreasonRemarks");
                        gTable.Columns.Add("RecordRemarks");
                        gTable.Columns.Add("OPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("MouldID", typeof(int));
                        gTable.Columns.Add("MouldCode");
                        gTable.Columns.Add("MouldOutputNo", typeof(int));
                        gTable.Columns.Add("GoodsID", typeof(int));
                        gTable.Columns.Add("GoodsCode");
                        gTable.Columns.Add("StandardGroutingCount", typeof(int));
                        gTable.Columns.Add("GroutingCount", typeof(int));
                        gTable.Columns.Add("MouldSource");

                        int groutingLineID = Convert.ToInt32(data["GroutingLineID"]);
                        string groutingLineCode = data["GroutingLineCode"] + "";
                        DateTime lineOPTimeStamp = Convert.ToDateTime(data["LineOPTimeStamp"]);

                        foreach (Dictionary<string, object> item in details)
                        {
                            int? mouldID = null;
                            if (item.ContainsKey("MouldID"))
                            {
                                mouldID = Convert.ToInt32(item["MouldID"]);
                                if (mouldID == 0)
                                {
                                    mouldID = null;
                                }
                            }
                            gTable.Rows.Add(groutingLineID, groutingLineCode, lineOPTimeStamp,
                                item["GLineDetailID"], item["GLineDetailCode"], item["DetailRemarks"],
                                item["RecordRemarks"], Convert.ToDateTime(item["OPTimeStamp"]),
                                mouldID, item["MouldCode"], item["MouldOutputNo"],
                                item["GoodsID"], item["GoodsCode"],
                                item["StandardGroutingCount"], item["GroutingCount"],
                                (mouldID == null ? "0" : "1"));
                        }

                        ServiceResultEntity result = PCModuleLogicDAL.ChangeGMouldEndGroutingLineDetail(gTable, sUserInfo);

                        if (result.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else if (result.OtherStatus == -100)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = -100;
                            actionResult.Message = result.Message;
                            return actionResult;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = -500;
                            actionResult.Message = "成型线状态已被更改，请刷新成型线数据";
                            return actionResult;
                        }

                        return actionResult;
                    }
                    #endregion
                    #region 结束变产
                    if (action == "UpdateLineEndGroutingLineDetail")
                    {
                        if (data == null || !data.ContainsKey("Details"))
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "参数错误";
                            return actionResult;
                        }
                        Dictionary<string, object>[] details = JsonHelper.FromJson<Dictionary<string, object>[]>(data["Details"].ToString());

                        DataTable gTable = new DataTable();
                        gTable.Columns.Add("GroutingLineID", typeof(int));
                        gTable.Columns.Add("GroutingLineCode");
                        gTable.Columns.Add("LineOPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("GroutingLineDetailID", typeof(int));
                        gTable.Columns.Add("GroutingMouldCode");
                        gTable.Columns.Add("RreasonRemarks");
                        gTable.Columns.Add("RecordRemarks");
                        gTable.Columns.Add("OPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("MouldID", typeof(int));
                        gTable.Columns.Add("MouldCode");
                        gTable.Columns.Add("MouldOutputNo", typeof(int));
                        gTable.Columns.Add("GoodsID", typeof(int));
                        gTable.Columns.Add("GoodsCode");
                        gTable.Columns.Add("StandardGroutingCount", typeof(int));
                        gTable.Columns.Add("GroutingCount", typeof(int));
                        gTable.Columns.Add("MouldSource");

                        int groutingLineID = Convert.ToInt32(data["GroutingLineID"]);
                        string groutingLineCode = data["GroutingLineCode"] + "";
                        DateTime lineOPTimeStamp = Convert.ToDateTime(data["LineOPTimeStamp"]);

                        foreach (Dictionary<string, object> item in details)
                        {
                            int? mouldID = null;
                            if (item.ContainsKey("MouldID"))
                            {
                                mouldID = Convert.ToInt32(item["MouldID"]);
                                if (mouldID == 0)
                                {
                                    mouldID = null;
                                }
                            }
                            gTable.Rows.Add(groutingLineID, groutingLineCode, lineOPTimeStamp,
                                item["GLineDetailID"], item["GLineDetailCode"], item["DetailRemarks"],
                                item["RecordRemarks"], Convert.ToDateTime(item["OPTimeStamp"]),
                                mouldID, item["MouldCode"], item["MouldOutputNo"],
                                item["GoodsID"], item["GoodsCode"],
                                item["StandardGroutingCount"], item["GroutingCount"],
                                (mouldID == null ? "0" : "1"));
                        }

                        ServiceResultEntity result = PCModuleLogicDAL.UpdateLineEndGroutingLineDetail(gTable, 0, sUserInfo);

                        if (result.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else if (result.OtherStatus == -100)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = -100;
                            actionResult.Message = result.Message;
                            return actionResult;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = -500;
                            actionResult.Message = "成型线状态已被更改，请刷新成型线数据";
                            return actionResult;
                        }

                        return actionResult;
                    }
                    #endregion
                    #region 结束整线变产
                    if (action == "UpdateAllLineEndGroutingLineDetail")
                    {
                        if (data == null || !data.ContainsKey("Details"))
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "参数错误";
                            return actionResult;
                        }
                        Dictionary<string, object>[] details = JsonHelper.FromJson<Dictionary<string, object>[]>(data["Details"].ToString());

                        DataTable gTable = new DataTable();
                        gTable.Columns.Add("GroutingLineID", typeof(int));
                        gTable.Columns.Add("GroutingLineCode");
                        gTable.Columns.Add("LineOPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("GroutingLineDetailID", typeof(int));
                        gTable.Columns.Add("GroutingMouldCode");
                        gTable.Columns.Add("Remarks");
                        gTable.Columns.Add("RecordRemarks");
                        //gTable.Columns.Add("OPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("MouldID", typeof(int));
                        gTable.Columns.Add("MouldCode");
                        gTable.Columns.Add("MouldOutputNo", typeof(int));
                        gTable.Columns.Add("GoodsID", typeof(int));
                        gTable.Columns.Add("GoodsCode");
                        gTable.Columns.Add("StandardGroutingCount", typeof(int));
                        gTable.Columns.Add("GroutingCount", typeof(int));
                        gTable.Columns.Add("MouldSource");

                        int groutingLineID = Convert.ToInt32(data["GroutingLineID"]);
                        string groutingLineCode = data["GroutingLineCode"] + "";
                        DateTime lineOPTimeStamp = Convert.ToDateTime(data["LineOPTimeStamp"]);

                        foreach (Dictionary<string, object> item in details)
                        {
                            int? mouldID = null;
                            if (item.ContainsKey("MouldID"))
                            {
                                mouldID = Convert.ToInt32(item["MouldID"]);
                                if (mouldID == 0)
                                {
                                    mouldID = null;
                                }
                            }
                            gTable.Rows.Add(groutingLineID, groutingLineCode, lineOPTimeStamp,
                                item["GLineDetailID"], item["GLineDetailCode"], item["DetailRemarks"],
                                item["RecordRemarks"], //Convert.ToDateTime(item["OPTimeStamp"]),
                                mouldID, item["MouldCode"], item["MouldOutputNo"],
                                item["GoodsID"], item["GoodsCode"],
                                item["StandardGroutingCount"], item["GroutingCount"],
                                (mouldID == null ? "0" : "1"));
                        }

                        ServiceResultEntity result = PCModuleLogicDAL.UpdateAllLineEndGroutingLineDetail(gTable, null, groutingLineID, lineOPTimeStamp, sUserInfo);

                        if (result.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else if (result.OtherStatus == -100)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = -100;
                            actionResult.Message = result.Message;
                            return actionResult;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = -500;
                            actionResult.Message = "成型线状态已被更改，请刷新成型线数据";
                            return actionResult;
                        }

                        return actionResult;
                    }
                    #endregion
                    #region 上模
                    if (action == "UpdateGroutingLine_AddMould")
                    {
                        if (data == null || !data.ContainsKey("Details"))
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "参数错误";
                            return actionResult;
                        }
                        Dictionary<string, object>[] details = JsonHelper.FromJson<Dictionary<string, object>[]>(data["Details"].ToString());

                        DataTable gTable = new DataTable();
                        gTable.Columns.Add("GroutingLineID", typeof(int));
                        gTable.Columns.Add("GroutingLineCode");
                        gTable.Columns.Add("LineOPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("GroutingLineDetailID", typeof(int));
                        gTable.Columns.Add("GroutingMouldCode");
                        gTable.Columns.Add("Remarks");
                        gTable.Columns.Add("RecordRemarks");
                        gTable.Columns.Add("OPTimeStamp", typeof(DateTime));
                        gTable.Columns.Add("MouldID", typeof(int));
                        gTable.Columns.Add("MouldCode");
                        gTable.Columns.Add("MouldOutputNo", typeof(int));
                        gTable.Columns.Add("GoodsID", typeof(int));
                        gTable.Columns.Add("GoodsCode");
                        gTable.Columns.Add("StandardGroutingCount", typeof(int));
                        gTable.Columns.Add("GroutingCount", typeof(int));
                        gTable.Columns.Add("MouldSource");

                        int groutingLineID = Convert.ToInt32(data["GroutingLineID"]);
                        string groutingLineCode = data["GroutingLineCode"] + "";
                        DateTime lineOPTimeStamp = Convert.ToDateTime(data["LineOPTimeStamp"]);

                        foreach (Dictionary<string, object> item in details)
                        {
                            int? mouldID = null;
                            if (item.ContainsKey("MouldID"))
                            {
                                mouldID = Convert.ToInt32(item["MouldID"]);
                                if (mouldID == 0)
                                {
                                    mouldID = null;
                                }
                            }
                            int gldID = Convert.ToInt32(item["GLineDetailID"]);
                            gTable.Rows.Add(groutingLineID, groutingLineCode, lineOPTimeStamp,
                                gldID, item["GLineDetailCode"],
                                item["DetailRemarks"], item["RecordRemarks"],
                                (gldID > 0 ? (object)Convert.ToDateTime(item["OPTimeStamp"]) : null),
                                mouldID, item["MouldCode"], item["MouldOutputNo"],
                                item["GoodsID"], item["GoodsCode"],
                                item["StandardGroutingCount"], item["GroutingCount"],
                                (mouldID == null ? "0" : "1"));
                        }

                        ServiceResultEntity result = PCModuleLogicDAL.UpdateGroutingLine_AddMould(groutingLineID, groutingLineCode, lineOPTimeStamp, gTable, sUserInfo);

                        if (result.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else if (result.OtherStatus == -2 || result.OtherStatus == -100)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = result.OtherStatus;
                            actionResult.Message = result.Message;
                            return actionResult;
                        }
                        else if (result.OtherStatus == -10001 || result.OtherStatus == -10002)
                        {
                            actionResult.Status = -99;
                            actionResult.Result = result.OtherStatus;
                            actionResult.Message = result.Message;
                            return actionResult;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = -500;
                            actionResult.Message = "成型线状态已被更改，请刷新成型线数据";
                            return actionResult;
                        }

                        return actionResult;
                    }
                    #endregion
                    return actionResult;
                }
                #endregion

                #region 包装装板限制
                if (module == "FinishedLoadingCar")
                {
                    if (action == "GetSetting")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["GoodsID"] = data["GoodsID"];
                        if (data.ContainsKey("logoID"))
                        {
                            cre.Properties["logoID"] = data["logoID"] + "";
                        }
                        else
                        {
                            cre.Properties["logoID"] = "";
                        }

                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.GetFinishedLoadingCarSetting(sUserInfo, cre);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            foreach (DataRow item in sre.Data.Tables[0].Rows)
                            {
                                if (item["settingcode"].ToString() == "S_PM_011")
                                {
                                    cre.Properties["S_PM_011"] = item["settingvalue"];
                                }
                                else if (item["settingcode"].ToString() == "S_PM_012")
                                {
                                    cre.Properties["S_PM_012"] = item["settingvalue"];
                                }
                                else if (item["settingcode"].ToString() == "S_PM_013")
                                {
                                    cre.Properties["S_PM_013"] = item["settingvalue"];
                                }
                            }

                            DataTable dt = sre.Result as DataTable;
                            cre.Properties["PlatelitNum"] = dt.Rows[0]["PLATELIMITNUM"];
                            cre.Properties["PlatelitNumNew"] = dt.Rows[0]["PLATELIMITNUMNEW"];

                            actionResult.Result = JsonHelper.ToJson(cre.Properties);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "";
                        }

                        return actionResult;
                    }
                }
                #endregion

                #region 成型报损
                if (module == "GroutingScrapProduct")
                {
                    // 查询注浆日报明细表
                    if ("GetGroutingDailyDetail" == action)
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.NameSpace = module;
                        cre.Name = action;
                        if (!string.IsNullOrEmpty(jsonData))
                        {
                            cre.Properties["BarCode"] = data["BarCode"];
                        }
                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.GetGroutingDailyDetail(cre, sUserInfo);
                        //actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);

                        actionResult.Status = (int)Constant.PDAResult.Success;

                        if (sre == null || sre.Data == null || sre.Data.Tables.Count == 0
                             || sre.Data.Tables[0].Rows.Count == 0)
                        {
                            actionResult.Message = "未查询到该产品信息，请确认该产品是否已经进行注浆!";
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                        }
                        else
                        {
                            DataRow _barCodeRow = sre.Data.Tables[0].Rows[0];
                            // 判断是否进行了注浆
                            if ("0".Equals(_barCodeRow["GroutingFlag"]))
                            {
                                actionResult.Message = "该产品还未进行注浆!";
                                actionResult.Status = (int)Constant.PDAResult.Fail;
                            }
                            // 判断是否进行了交坯
                            if ("1".Equals(_barCodeRow["DeliverFlag"]))
                            {
                                actionResult.Message = "该产品已经交坯!";
                                actionResult.Status = (int)Constant.PDAResult.Fail;
                            }
                            // 判断是否已经报损
                            if ("1".Equals(_barCodeRow["ScrapFlag"]))
                            {
                                actionResult.Message = "该产品已经报损!";
                                actionResult.Status = (int)Constant.PDAResult.Fail;
                            }
                            // 该产品已进入生产工序
                            if ("1".Equals(_barCodeRow["beginningflag"]))
                            {
                                actionResult.Message = "该产品已进入生产工序!";
                                actionResult.Status = (int)Constant.PDAResult.Fail;
                            }
                            actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        }

                    }
                    // 获取成型报损原因
                    else if ("GetScrapReasonData" == action)
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.NameSpace = module;
                        cre.Name = action;
                        ServiceResultEntity sre = SystemModuleLogic.GetScrapReasonData(cre, sUserInfo, "1");
                        actionResult.Status = (int)Constant.PDAResult.Success;
                        actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);

                    }
                    // 保存成型报损
                    else if ("SaveGroutingScrapProduct" == action)
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.NameSpace = module;
                        cre.Name = action;
                        if (!string.IsNullOrEmpty(jsonData))
                        {
                            // DataSet returnData = JsonHelper.FromJson<DataSet>(jsonData);
                            DataTable dt = JsonHelper.FromJson<DataTable>(data["Table"] + "");
                            DataTable dtResponsible = JsonHelper.FromJson<DataTable>(data["Table1"] + "");
                            if (dt != null && dt.Rows.Count > 0)
                            {
                                // 总单信息
                                DataRow properties = dt.Rows[0];
                                cre.Properties["BarCode"] = properties["BarCode"]; // 产品条码
                                cre.Properties["GoodsID"] = properties["GoodsID"];  // 产品ID
                                cre.Properties["GoodsCode"] = properties["GoodsCode"];  // 产品编码
                                cre.Properties["GoodsName"] = properties["GoodsName"];  // 产品名称
                                cre.Properties["GroutingDailyID"] = properties["GroutingDailyID"];  // 注浆日报ID
                                cre.Properties["GroutingDailyDetailID"] = properties["GroutingDailyDetailID"]; // 注浆日报明细ID
                                cre.Properties["GroutingDate"] = properties["GroutingDate"]; // 注浆日期
                                cre.Properties["GroutingLineID"] = properties["GroutingLineID"]; // 成型生产线ID
                                cre.Properties["GroutingLineCode"] = properties["GroutingLineCode"]; // 成型生产线编码
                                cre.Properties["GroutingLineName"] = properties["GroutingLineName"]; // 成型生产线名称
                                cre.Properties["GMouldTypeID"] = properties["GMouldTypeID"]; // 成型线类型ID
                                cre.Properties["GroutingLineDetailID"] = properties["GroutingLineDetailID"]; // 成型生产线明细ID
                                cre.Properties["GroutingMouldCode"] = properties["GroutingMouldCode"]; // 注浆模具编号
                                cre.Properties["MouldCode"] = properties["MouldCode"]; // 模具编号
                                cre.Properties["GroutingUserID"] = properties["GroutingUserID"]; // 注浆工号ID
                                cre.Properties["GroutingUserCode"] = properties["GroutingUserCode"]; // 注浆工号编码
                                cre.Properties["GroutingNum"] = properties["GroutingNum"]; // 注浆次数
                                cre.Properties["ScrapType"] = properties["ScrapType"]; // 损坯类型
                                cre.Properties["ScrapDate"] = properties["ScrapDate"]; // 报损日期
                                cre.Properties["ScrapRreasonID"] = properties["ScrapRreasonID"]; // 报损日期
                                cre.Properties["ResponUserID"] = properties["ResponUserID"]; // 损坯工号
                                cre.Properties["ResponUserCode"] = properties["ResponUserCode"];
                                cre.Properties["Remarks"] = properties["Remarks"]; // 备注
                                cre.Properties["AuditStatus"] = properties["AuditStatus"]; // 审批状态

                                // 责任员工
                                cre.Data = new DataSet();
                                //DataTable returnTable = returnData.Tables[1].Copy();
                                cre.Data.Tables.Add(dtResponsible);
                            }
                        }
                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.SaveGroutingScrapProduct(cre, sUserInfo);

                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = sre.Result;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = sre.OtherStatus;
                            actionResult.Message = sre.Message;
                        }
                    }
                    // 获取成型报损信息 用于撤销使用
                    else if ("GetGroutingScrapProduct" == action)
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.NameSpace = module;
                        cre.Name = action;
                        if (!string.IsNullOrEmpty(jsonData))
                        {
                            cre.Properties["BarCode"] = data["BarCode"];
                        }
                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.GetGroutingScrapProduct(cre, sUserInfo);
                        actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        actionResult.Status = (int)Constant.PDAResult.Success;

                    }
                    //xuwei add 2020-03-23
                    //获取成型报损信息 用于撤销使用 支持 浆日报直接报损
                    else if ("GetGroutingScrap" == action)
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.NameSpace = module;
                        cre.Name = action;
                        if (!string.IsNullOrEmpty(jsonData))
                        {
                            cre.Properties["BarCode"] = data["BarCode"];
                        }
                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.GetGroutingScrap(cre, sUserInfo);
                        actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        actionResult.Status = (int)Constant.PDAResult.Success;

                    }
                    // 撤销成型报损
                    else if ("ReverseGroutingScrapProduct" == action)
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.NameSpace = module;
                        cre.Name = action;
                        if (!string.IsNullOrEmpty(jsonData))
                        {
                            cre.Properties["BarCode"] = data["BarCode"];
                        }
                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.ReverseGroutingScrapProduct(cre, sUserInfo);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = sre.Result;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = sre.OtherStatus;
                            actionResult.Message = sre.Message;
                        }
                    }
                }
                #endregion

                #region 产品挂起
                if (module == "ProductSuspend")
                {
                    // 获取可以挂起的工序（干补、装车、入窑、出窑）工序不能挂起
                    if (action == "GetSuspendProcedure")
                    {
                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.GetSuspendProcedure(sUserInfo);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }

                        return actionResult;
                    }
                    // 验证挂起条码
                    if (action == "CheckSuspendBarcode")
                    {
                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.CheckSuspendBarcode(sUserInfo, data["barcode"] + "");
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }

                        return actionResult;
                    }
                    // 挂起条码
                    if (action == "SaveSuspendProduct")
                    {
                        int[] gids = JsonHelper.FromJson<int[]>(data["groutingdailydetailids"] + "");
                        int[] pids = JsonHelper.FromJson<int[]>(data["procedureids"] + "");

                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.SaveSuspendProduct(sUserInfo, pids, gids, data["remarks"] + "");
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            //actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }

                        return actionResult;
                    }
                    // 撤销挂起条码
                    if (action == "DeleteSuspendProduct")
                    {
                        int[] gids = JsonHelper.FromJson<int[]>(data["groutingdailydetailids"] + "");
                        int[] pids = JsonHelper.FromJson<int[]>(data["procedureids"] + "");

                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.DeleteSuspendProduct(sUserInfo, pids, gids);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            //actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }

                        return actionResult;
                    }
                    // 查询挂起条码
                    if (action == "GetSuspendProduct")
                    {
                        ServiceResultEntity sre = Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.GetSuspendProduct(sUserInfo, data["barcode"] + "");
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            if (sre.Data.Tables[0].Rows.Count == 0)
                            {
                                actionResult.Status = (int)Constant.PDAResult.Fail;
                                actionResult.Message = "此条码没有可撤销的挂起信息";
                            }
                            else
                            {
                                actionResult.Status = (int)Constant.PDAResult.Success;
                                actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                            }
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }

                        return actionResult;
                    }

                }
                #endregion

                #region 品保抽查
                if (module == "QASpotCheck")
                {
                    if (action == "GetAllQASpotCheck")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.NameSpace = module;
                        cre.Name = action;
                        if (data != null && data.Count > 0)
                        {
                            foreach (string item in data.Keys)
                            {
                                if (item.StartsWith("checktime"))
                                {
                                    cre.Properties.Add(item, DateTime.ParseExact(data[item] + "", "yyyy-MM-dd", null));
                                }
                                else
                                {
                                    cre.Properties.Add(item, data[item]);
                                }
                            }
                        }
                        ServiceResultEntity sre = ServiceInvoker.Invoke(this, () => Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.GetAllQASpotCheck(sUserInfo, cre));
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        }
                        else if (sre.Status == Constant.ServiceResultStatus.NoSearchResults)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }

                        return actionResult;
                    }
                    if (action == "AutoSaveQASpotCheck")
                    {
                        string barcode = data["barcode"] + "";
                        string remarks = data["remarks"] + "";
                        ServiceResultEntity sre = ServiceInvoker.Invoke(this, () => Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.AutoSaveQASpotCheck(sUserInfo, barcode, remarks));
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }

                        return actionResult;
                    }
                    if (action == "CheckQASpotCheck")
                    {
                        ServiceResultEntity sre = ServiceInvoker.Invoke(this, () => Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.CheckQASpotCheck(sUserInfo, jsonData));
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }

                        return actionResult;
                    }
                    if (action == "SaveQASpotCheck")
                    {
                        data["CheckTime"] = DateTime.ParseExact(data["CheckTime"] + "", "yyyy-MM-dd HH:mm:ss", null);
                        ServiceResultEntity sre = ServiceInvoker.Invoke(this, () => Dongke.IBOSS.PRD.Service.PMModuleService.PMModuleLogic.SaveQASpotCheck(sUserInfo, data));
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }

                        return actionResult;
                    }
                    return null;
                }
                #endregion

                #region 产成品交接
                if (module == "FinishedProduct")
                {
                    #region 产成品交接、整板撤销 by fubin 20200824
                    // 交接验证
                    if (action == "FinishedHandoverBarcode")
                    {
                        string barcode = data["Barcode"] + "";
                        ServiceResultEntity sre = PMModuleLogic.FinishedHandoverBarcode(barcode, sUserInfo);

                        if (sre.Data != null && sre.Data.Tables.Count > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data);
                            actionResult.Message = sre.Message;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                    // 交接操作
                    if (action == "SaveFinishedHandover")
                    {
                        int orderID = Convert.ToInt32(data["OrderID"]);
                        DataTable dt = JsonHelper.FromJson<DataTable>(data["Table"] + "");

                        //切换sap地址 by fy 2022年7月5日09:15:23 开始
                        //ServiceResultEntity sre = PMModuleLogicDAL.SaveFinishedHandover(orderID, dt, sUserInfo);
                        string sapName = "";
                        if (data.ContainsKey("SPANAME") && data["SPANAME"] is object &&
                            (data["SPANAME"].Equals("APP1") || data["SPANAME"].Equals("APP2") || data["SPANAME"].Equals("APP3")))
                        {
                            sapName = "_" + data["SPANAME"].ToString();
                        }
                        else
                        {
                            sapName = "";
                        }
                        ServiceResultEntity sre = PMModuleLogicDAL.SaveFinishedHandover(orderID, dt, sUserInfo, sapName);
                        //结束

                        if (Convert.ToInt32(sre.Result) > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Message = "产成品交接成功";
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                    // 撤销交接验证
                    if (action == "BackFinishedHandoverCheck")
                    {
                        string barcode = data["Barcode"] + "";
                        ServiceResultEntity sre = PMModuleLogic.BackFinishedHandoverCheck(barcode, sUserInfo);

                        if (sre.Data != null && sre.Data.Tables.Count > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data);
                            actionResult.Message = sre.Message;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                    // 撤销交接操作
                    if (action == "BackFinishedHandover")
                    {
                        DataTable dt = JsonHelper.FromJson<DataTable>(data["Table"] + "");
                        ServiceResultEntity sre = PMModuleLogicDAL.BackFinishedHandover(dt, sUserInfo);

                        if (Convert.ToInt32(sre.Result) > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Message = "产成品撤销交接成功";
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                    #endregion

                    // 设定商标
                    if (action == "GetFinishedBarcode")
                    {
                        string barcode = data["barcode"].ToString();
                        ServiceResultEntity resultEntity = PMModuleLogic.FinishedHandoverBarcode(barcode, sUserInfo, 2);

                        //actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                        if (Convert.ToInt32(resultEntity.Result) < 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = resultEntity.OtherStatus; //漏扫1,反之0
                            actionResult.Message = resultEntity.Message;
                        }
                        else
                        {
                            actionResult.Result = JsonHelper.ToJson(resultEntity.Data);
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Message = resultEntity.Message;
                        }
                        return actionResult;
                    }
                    if (action == "GetHandoveredBarcode")
                    {
                        string barcode = data["barcode"].ToString();
                        ServiceResultEntity resultEntity = PMModuleLogic.FinishedHandoverBarcode(barcode, sUserInfo, 1);

                        //actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                        if (Convert.ToInt32(resultEntity.Result) < 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = resultEntity.OtherStatus; //漏扫1,反之0
                            actionResult.Message = resultEntity.Message;
                        }
                        else
                        {
                            actionResult.Result = JsonHelper.ToJson(resultEntity.Data);
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Message = resultEntity.Message;
                        }
                        return actionResult;
                    }
                    if (action == "SetFinishedLogo")
                    {
                        int logoid = Convert.ToInt32(data["logoid"]);
                        string[] barcodes = data["barcodes"].ToString().Split(',');

                        string returnMessage = "";
                        int result = PMModuleLogicDAL.SetFinishedLogo(barcodes, logoid, sUserInfo, out returnMessage);

                        //actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                        if (result < 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = returnMessage;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        return actionResult;
                    }
                    if (action == "SetHandoveredOrder")
                    {
                        int orderID = Convert.ToInt32(data["orderID"]);
                        string[] barcodes = data["barcodes"].ToString().Split(',');

                        int result = PMModuleLogicDAL.SetHandoveredOrder(barcodes, orderID, sUserInfo);

                        //actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                        if (result < 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        return actionResult;
                    }
                }
                #endregion

                #region 产成品装车
                /*
                if (module == "FinishedLoading")
                {
                    // 设定商标
                    if (action == "GetMaxLoadingNo")
                    {
                        int no = Service.PMModuleService.PMModuleLogic.GetMaxLoadingNo(sUserInfo);

                        actionResult.Status = (int)Constant.PDAResult.Success;
                        actionResult.Result = no;
                        return actionResult;
                    }
                    if (action == "CheckFinishedLaodingBarcode")
                    {
                        string barcode = data["barcode"].ToString();
                        ServiceResultEntity resultEntity = Service.PMModuleService.PMModuleLogic.CheckFinishedLaodingBarcode(sUserInfo, barcode);

                        if (resultEntity.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Result = JsonHelper.ToJson(resultEntity.Data);
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Message = resultEntity.Message;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = resultEntity.OtherStatus;
                            actionResult.Message = resultEntity.Message;
                        }
                        return actionResult;
                    }
                    if (action == "SaveFinishedLoading")
                    {
                        int loadingNo = Convert.ToInt32(data["loadingNo"]);
                        string carLicense = data["carLicense"] + "";
                        int palletNum = Convert.ToInt32(data["palletNum"]);
                        int goodsNum = Convert.ToInt32(data["goodsNum"]);
                        string remarks = data["remarks"] + "";
                        Dictionary<string, object>[] details =
                            JsonHelper.FromJson<Dictionary<string, object>[]>(data["details"] + "");
                        //"[{\"A\":1,\"B\":\"V\"},{\"A\":2,\"B\":\"V1\"}]"

                        ServiceResultEntity result = Service.PMModuleService.PMModuleLogic.SaveFinishedLoading(sUserInfo,
                            loadingNo, carLicense, palletNum, goodsNum, remarks, details);

                        if (result.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Message = result.Message;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = result.OtherStatus;
                            actionResult.Message = result.Message;
                        }
                        return actionResult;
                    }
                }
                */
                #endregion

                #region 产成品质量改判
                if (module == "FinishedProductTamper")
                {
                    // 获取产成品信息及缺陷数据
                    if (action == "GetDefectData")
                    {
                        string barcode = data["barcode"].ToString();
                        ServiceResultEntity sre = PDAModuleLogic.GetDefectData(barcode, sUserInfo);

                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Result);
                            actionResult.Message = sre.Message;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = sre.OtherStatus;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }

                    // 获取产成品信息及缺陷数据
                    if (action == "SaveDefectData")
                    {
                        ProductionDataEntity productionDataEntity = JsonHelper.FromJson<ProductionDataEntity>(data["ProductionDataEntity"] + "");
                        ServiceResultEntity sre = PDAModuleLogic.SaveDefectData(productionDataEntity, sUserInfo);

                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Message = sre.Message;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }

                    // 通过条码查出责任工序(成品改判用)
                    if (action == "GetDutyProcedureByBarCodeForTamper")
                    {
                        string barcode = data["barcode"] + "";
                        int defectid = int.Parse(data["defectid"] + "");
                        ServiceResultEntity sre = PDAModuleLogic.GetDutyProcedureByBarCodeForTamper(barcode, defectid, sUserInfo.AccountID);

                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data);
                            actionResult.Message = sre.Message;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = sre.OtherStatus;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                }
                #endregion

                #region PDA独立功能

                #region 水效标识
                if (module == "WaterEffect")
                {
                    // 获取产成品信息及水效标识
                    if (action == "GetGoodsByBarCode")
                    {
                        string barcode = data["barcode"].ToString();
                        ServiceResultEntity sre = PDAModuleLogic.GetGoodsByBarCode(barcode, sUserInfo);

                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Result);
                            actionResult.Message = sre.Message;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = sre.OtherStatus;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                }
                #endregion

                #region 盖板型号
                if (module == "SeatCoverType")
                {
                    // 获取产成品信息及水效标识
                    if (action == "SendGoodsCodeToPLC")
                    {
                        string barcode = data["barcode"].ToString();
                        int sre = PLCModuleLogic.SendGoodsCodeToPLCBySeatCover(barcode, sUserInfo);

                        if (sre == 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = sre;
                            switch (sre)
                            {
                                case 1:
                                case 2:
                                    actionResult.Message = "无效条码";
                                    break;
                                case 3:
                                    actionResult.Message = "此产品型号没有设置盖板标识码";
                                    break;
                                case 4:
                                    actionResult.Message = "当前用户没有设置PLC参数";
                                    break;
                                case 5:
                                    actionResult.Message = "PLC参数设置不全";
                                    break;
                                default:
                                    actionResult.Message = "PLC通信异常";
                                    break;
                            }
                        }
                        return actionResult;
                    }
                }
                #endregion

                #region PDA PLC 相关功能
                if (module == "PDA_FUN_PLC")
                {
                    // PDA扫码发送到PLCServer
                    if (action == "SendBarcodeToPLCServer")
                    {
                        string barcode = data["barcode"].ToString();
                        int sre = PLCModuleLogic.SendBarcodeToPLCServer(barcode, sUserInfo);

                        if (sre == 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = sre;
                            switch (sre)
                            {
                                case 1:
                                case 2:
                                    actionResult.Message = "无效条码";
                                    break;
                                case 3:
                                    actionResult.Message = "PLC通信异常";
                                    break;
                                case 4:
                                    actionResult.Message = "当前用户没有设置PLC参数";
                                    break;
                                case 5:
                                    actionResult.Message = "PLC参数设置不全";
                                    break;
                                default:
                                    actionResult.Message = "PLC通信异常";
                                    break;
                            }
                        }
                        return actionResult;
                    }
                }
                #endregion

                #endregion

                #region 半检返修
                if (module == "SemiRework")
                {
                    // 验证半检返修条码
                    if (action == "CheckSemiReworkBarcode")
                    {
                        ServiceResultEntity resultEntity = Dongke.IBOSS.PRD.Service.PMModuleService.
                            PMModuleLogic.CheckSemiReworkBarcode(jsonData);

                        actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                        if (Convert.ToInt32(resultEntity.Result) < 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        actionResult.Message = resultEntity.Message;
                        return actionResult;
                    }

                    // 可以返修的工序
                    if (action == "GetSemiReworkProcedure")
                    {
                        ServiceResultEntity resultEntity = Dongke.IBOSS.PRD.Service.PMModuleService.
                            PMModuleLogic.GetSemiReworkProcedure(jsonData, sUserInfo);

                        actionResult.Result = JsonHelper.ToJson(resultEntity.Data);
                        actionResult.Status = (int)Constant.PDAResult.Success;
                        return actionResult;
                    }

                    // 根据条码获取经过的工序,用于责任工序
                    if (action == "GetSemiReworkPassProcedure")
                    {
                        ServiceResultEntity resultEntity = Dongke.IBOSS.PRD.Service.PMModuleService.
                            PMModuleLogic.GetSemiReworkPassProcedure(jsonData);

                        actionResult.Result = JsonHelper.ToJson(resultEntity.Data);
                        actionResult.Status = (int)Constant.PDAResult.Success;
                        return actionResult;
                    }
                    // 根据所选生产工序（生产数据ID）查询责任员工
                    if (action == "GetSemiReworkDefectStaffByProductionDataID")
                    {
                        int productionDataID = Convert.ToInt32(jsonData);
                        ServiceResultEntity resultEntity = Dongke.IBOSS.PRD.Service.PMModuleService.
                            PMModuleLogic.GetSemiReworkDefectStaffByProductionDataID(productionDataID);

                        actionResult.Result = JsonHelper.ToJson(resultEntity.Data);
                        actionResult.Status = (int)Constant.PDAResult.Success;
                        return actionResult;
                    }
                    // 根据所选工号，查出缺陷责任员工
                    if (action == "GetSemiReworkDefectStaffByUserID")
                    {
                        int userID = Convert.ToInt32(jsonData);
                        ServiceResultEntity resultEntity = Dongke.IBOSS.PRD.Service.PMModuleService.
                            PMModuleLogic.GetSemiReworkDefectStaffByUserID(userID);

                        actionResult.Result = JsonHelper.ToJson(resultEntity.Data);
                        actionResult.Status = (int)Constant.PDAResult.Success;
                        return actionResult;
                    }
                    // 新建半检返修
                    if (action == "AddSemiRework")
                    {
                        SemiReworkEntity entity = JsonHelper.FromJson<SemiReworkEntity>(data["SemiReworkEntity"] + "");
                        ServiceResultEntity resultEntity = Dongke.IBOSS.PRD.Service.PMModuleService.
                            PMModuleLogic.AddSemiRework(entity, sUserInfo);

                        actionResult.Result = resultEntity.Result;
                        actionResult.Message = resultEntity.Message;
                        if (Convert.ToInt32(resultEntity.Result) > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                        }
                        return actionResult;
                    }
                    // 编辑半检返修
                    if (action == "EditSemiRework")
                    {
                        SemiReworkEntity entity = JsonHelper.FromJson<SemiReworkEntity>(data["SemiReworkEntity"] + "");
                        ServiceResultEntity resultEntity = Dongke.IBOSS.PRD.Service.PMModuleService.
                            PMModuleLogic.EditSemiRework(entity, sUserInfo);

                        actionResult.Result = resultEntity.Result;
                        actionResult.Message = resultEntity.Message;
                        if (Convert.ToInt32(resultEntity.Result) > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                        }
                        return actionResult;
                    }
                    // 撤销半检返修
                    if (action == "CancelSemiRework")
                    {
                        SemiReworkEntity entity = JsonHelper.FromJson<SemiReworkEntity>(data["SemiReworkEntity"] + "");
                        ServiceResultEntity resultEntity = Dongke.IBOSS.PRD.Service.PMModuleService.
                            PMModuleLogic.CancelSemiRework(entity, sUserInfo);

                        actionResult.Result = resultEntity.Result;
                        actionResult.Message = resultEntity.Message;
                        if (Convert.ToInt32(resultEntity.Result) > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                        }
                        return actionResult;
                    }
                    // 获取半检返修数据（PDA编辑用）
                    if (action == "GetSemiReworkByID")
                    {
                        int id = Convert.ToInt32(jsonData);
                        ServiceResultEntity resultEntity = Dongke.IBOSS.PRD.Service.PMModuleService.
                            PMModuleLogic.GetSemiReworkByID(id, sUserInfo.UserCode);

                        DataTable data1 = resultEntity.Data.Tables[0];
                        DataTable data2 = resultEntity.Data.Tables[1];
                        DataTable data3 = resultEntity.Data.Tables[2];

                        if (data1.Rows.Count == 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = "半检返修信息不存在";
                            return actionResult;
                        }

                        SemiReworkEntity srEntity = new SemiReworkEntity();
                        srEntity.SemiReworkID = id;
                        srEntity.BarCode = data1.Rows[0]["BarCode"] + "";
                        srEntity.ReworkProcedureID = Convert.ToInt32(data1.Rows[0]["ReworkProcedureID"]);
                        srEntity.Remarks = data1.Rows[0]["Remarks"] + "";
                        srEntity.SemiReworkDefects = new List<SemiReworkDefectEntity>();
                        foreach (DataRow row2 in data2.Rows)
                        {
                            SemiReworkDefectEntity defectEntity = new SemiReworkDefectEntity();
                            srEntity.SemiReworkDefects.Add(defectEntity);
                            defectEntity.SemiReworkDefectID = Convert.ToInt32(row2["SemiReworkDefectID"]);
                            defectEntity.SemiReworkID = id;
                            defectEntity.DefectID = Convert.ToInt32(row2["DefectID"]);
                            defectEntity.DefectCode = row2["DefectCode"] + "";
                            defectEntity.DefectName = row2["DefectName"] + "";
                            defectEntity.DefectPositionID = Convert.ToInt32(row2["DefectPositionID"]);
                            defectEntity.DefectPositionCode = row2["DefectPositionCode"] + "";
                            defectEntity.DefectPositionName = row2["DefectPositionName"] + "";
                            defectEntity.ScrapResponFlag = row2["ScrapResponFlag"] + "";
                            defectEntity.DefectProductionDataID = row2["DefectProductionDataID"].ToNullableInt32();
                            defectEntity.DefectProcedureID = row2["DefectProcedureID"].ToNullableInt32();
                            defectEntity.DefectProcedureCode = row2["DefectProcedureCode"] + "";
                            defectEntity.DefectProcedureName = row2["DefectProcedureName"] + "";
                            defectEntity.Remarks = row2["Remarks"] + "";
                            defectEntity.DefectUserID = Convert.ToInt32(row2["DefectUserID"]);
                            defectEntity.DefectUserCode = row2["DefectUserCode"] + "";
                            defectEntity.DefectUserName = row2["DefectUserName"] + "";
                            defectEntity.DefectResponsibles = new List<SemiReworkRPSEntity>();
                            defectEntity.ValueFlag = Convert.ToInt32(row2["ValueFlag"]);

                            DataRow[] row3s = data3.Select("SemiReworkDefectID=" + defectEntity.SemiReworkDefectID);
                            if (row3s.Length == 0)
                            {
                                continue;
                            }

                            foreach (DataRow row3 in row3s)
                            {
                                SemiReworkRPSEntity semiReworkRPS = new SemiReworkRPSEntity();
                                defectEntity.DefectResponsibles.Add(semiReworkRPS);
                                semiReworkRPS.SemiReworkDefectID = Convert.ToInt32(row3["SemiReworkDefectID"]);
                                semiReworkRPS.StaffID = Convert.ToInt32(row3["StaffID"]);
                                semiReworkRPS.StaffName = row3["StaffName"] + "";
                                semiReworkRPS.StaffCode = row3["StaffCode"] + "";
                                semiReworkRPS.SemiReworkID = Convert.ToInt32(row3["SemiReworkID"]);
                                semiReworkRPS.UserID = Convert.ToInt32(row3["UserID"]);
                                semiReworkRPS.UserCode = row3["UserCode"] + "";
                                semiReworkRPS.UJobsID = Convert.ToInt32(row3["UJobsID"]);
                                semiReworkRPS.SJobsID = Convert.ToInt32(row3["SJobsID"]);
                            }
                        }
                        //xuwei note 总单用于显示，信息较全
                        actionResult.Message = JsonHelper.ToJson(data1);
                        //xuwei note 总单信息不全，但有明细，用于回传保存
                        actionResult.Result = JsonHelper.ToJson(srEntity);
                        actionResult.Status = (int)Constant.PDAResult.Success;
                    }
                }
                #endregion

                #region 窑车漏扫补件
                if (module == "F_PM_0504")
                {
                    // 验证窑车编码是否存在
                    if (action == "CheckKilnCar")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["kilncarcode"] = data["KilnCarCode"];
                        cre.Properties["procedureID"] = data["ProcedureID"];
                        ServiceResultEntity sre = Service.PMModuleService.PMModuleLogic.CheckKilnCar(cre, sUserInfo);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = sre.Result;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                    // 验证窑车烧成批次号是否存在 和 是否能补漏扫
                    if (action == "CheckKilnCarBatchNo")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["KilnID"] = data["KilnID"];
                        cre.Properties["KilnCarID"] = data["KilnCarID"];
                        cre.Properties["ProcedureID"] = data["ProcedureID"];
                        cre.Properties["KilnCarBatchNo"] = data["KilnCarBatchNo"];
                        ServiceResultEntity sre = Service.PMModuleService.PMModuleLogic.CheckKilnCarBatchNo(cre, sUserInfo);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                    // 窑车漏扫补件
                    if (action == "SetKilnCarMissing")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["KilnCarBatchNo"] = data["KilnCarBatchNo"];
                        string carData = data["CarData"] + "";
                        DataTable dataTable = JsonHelper.FromJson<DataTable>(carData);
                        cre.Data = new DataSet();
                        cre.Data.Tables.Add(dataTable);
                        ServiceResultEntity sre = Service.PMModuleService.PMModuleLogic.SetKilnCarMissing(cre, sUserInfo);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                }
                #endregion

                #region 梭式窑入窑
                else if (module == "F_PM_0505")
                {
                    // 验证窑车编码是否存在
                    if (action == "GetAllKilntInfo")
                    {
                        DataSet dsKilntInfo = SystemModuleLogic.GetAllKilntInfo(sUserInfo);
                        if (dsKilntInfo != null && dsKilntInfo.Tables.Count > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(dsKilntInfo.Tables[0]);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                        }
                        return actionResult;
                    }
                    // 保存梭式窑入窑计数
                    if (action == "SaveSKBatchNo")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["KilnCode"] = data["KilnCode"];
                        cre.Properties["Remarks"] = data["Remarks"];
                        ServiceResultEntity sre = Service.PMModuleService.PMModuleLogic.SaveSKBatchNo(cre, sUserInfo);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            if (sre.OtherStatus > 0)
                            {
                                actionResult.Status = (int)Constant.PDAResult.Success;
                            }
                            else
                            {
                                actionResult.Status = (int)Constant.PDAResult.Fail;
                                actionResult.Message = sre.Message;
                            }
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                }
                #endregion

                #region 重启3#高压注浆
                else if (module == "F_PM_0107")
                {
                    // 查询3#高压注浆线
                    if (action == "GetGroutingLine3")
                    {
                        ServiceResultEntity sre = Service.PMModuleService.PMModuleLogic.GetGroutingLine3(sUserInfo);
                        if (sre.Data != null && sre.Data.Tables.Count > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                        }
                        return actionResult;
                    }
                    // 重置注浆批次
                    if (action == "SaveGroutingLine3")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["GroutingLineID"] = data["GroutingLineID"];
                        cre.Properties["H_BatchNo"] = data["H_BatchNo"];

                        ServiceResultEntity sre = Service.PMModuleService.PMModuleLogic.SaveGroutingLine3(cre, sUserInfo);

                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            if (sre.OtherStatus > 0)
                            {
                                actionResult.Status = (int)Constant.PDAResult.Success;
                            }
                            else
                            {
                                actionResult.Status = (int)Constant.PDAResult.Fail;
                                actionResult.Message = sre.Message;
                            }
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                }
                #endregion

                #region 3#条码打印机（PDA用）
                // 3#配置工位打印机
                else if (module == "01070804")
                {
                    // 获取3#条码打印机配置（PDA用）
                    if (action == "GetWorkStationPrinter3")
                    {
                        ServiceResultEntity sre = SystemModuleLogic.GetWorkStationPrinter3(sUserInfo);
                        if (sre.Data != null && sre.Data.Tables.Count > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                        }
                        return actionResult;
                    }
                    // 保存3#条码打印机配置（PDA用）
                    else if (action == "SaveWorkStationPrinter3")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["WorkStationID"] = data["WorkStationID"];
                        cre.Properties["PrinterID1"] = data["PrinterID1"];
                        cre.Properties["PrinterID2"] = data["PrinterID2"];
                        cre.Properties["PrinterID3"] = data["PrinterID3"];

                        ServiceResultEntity sre = SystemModuleLogic.SaveWorkStationPrinter3(cre, sUserInfo);

                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            if (sre.OtherStatus > 0)
                            {
                                actionResult.Status = (int)Constant.PDAResult.Success;
                            }
                            else
                            {
                                actionResult.Status = (int)Constant.PDAResult.Fail;
                                actionResult.Message = sre.Message;
                            }
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                }
                // 3#条码打印
                else if (module == "01070805")
                {
                    // 获取3#条码打印机配置（PDA用）
                    if (action == "GetWorkStationPrinter3")
                    {
                        ServiceResultEntity sre = SystemModuleLogic.GetWorkStationPrinter3(sUserInfo);
                        if (sre.Data != null && sre.Data.Tables.Count > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                        }
                        return actionResult;
                    }
                    // 条码打印（PDA用）
                    else if (action == "PrintBarcode_3BL")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["Barcode"] = data["Barcode"];
                        cre.Properties["WorkStationID"] = data["WorkStationID"];

                        ServiceResultEntity sre = SystemModuleLogic.PrintBarcode_3BL(cre, sUserInfo);

                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            if (sre.Result != null)
                            {
                                actionResult.Status = (int)Constant.PDAResult.Success;
                            }
                            else
                            {
                                actionResult.Status = (int)Constant.PDAResult.Fail;
                                actionResult.Message = sre.Message;
                            }
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                }
                // 3#条码补打
                else if (module == "01070806")
                {
                    // 获取3#条码打印机配置（PDA用）
                    if (action == "GetWorkStationPrinter3")
                    {
                        ServiceResultEntity sre = SystemModuleLogic.GetWorkStationPrinter3(sUserInfo);
                        if (sre.Data != null && sre.Data.Tables.Count > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data);
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                        }
                        return actionResult;
                    }
                    // 补打3#条码（PDA用）
                    else if (action == "PrintBarcode_3BL_B")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        cre.Properties["Barcode"] = data["Barcode"];

                        if (data.ContainsKey("PrinterID1"))
                            cre.Properties["PrinterID1"] = data["PrinterID1"];

                        if (data.ContainsKey("PrinterID2"))
                            cre.Properties["PrinterID2"] = data["PrinterID2"];

                        if (data.ContainsKey("PrinterID3"))
                            cre.Properties["PrinterID3"] = data["PrinterID3"];

                        ServiceResultEntity sre = SystemModuleLogic.PrintBarcode_3BL_B(cre, sUserInfo);

                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            if (sre.Result != null)
                            {
                                actionResult.Status = (int)Constant.PDAResult.Success;
                            }
                            else
                            {
                                actionResult.Status = (int)Constant.PDAResult.Fail;
                                actionResult.Message = sre.Message;
                            }
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                }
                #endregion

                #region 获取3#成检二检PLC重量
                else if (module == "GetPLCWeight")
                {
                    // 获取3#条码打印机配置（PDA用）
                    if (action == "GetPLCWeight")
                    {
                        actionResult.Result = PMModuleLogic.Get3PLCWeight(sUserInfo);
                        actionResult.Status = (int)Constant.PDAResult.Success;
                        return actionResult;
                    }
                }
                #endregion

                #region 注浆绑码时，验证成型线是否能绑码
                else if (module == "CheckGroutingLine")
                {
                    if (action == "CheckGroutingLine")
                    {
                        ServiceResultEntity sre = PDAModuleLogic.CheckGroutingLine(data["GroutingLineCode"] + "");
                        if (sre.OtherStatus < 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }

                        return actionResult;
                    }
                }
                #endregion

                #region 注浆绑码选批次查询最小启用的模具编码
                else if (module == "GetGroutingMouldByBatchNo")
                {
                    if (action == "GetGroutingMouldByBatchNo")
                    {
                        string groutingLineCode = data["groutingLineCode"] + "";
                        string groutingDay = data["groutingDay"] + "";
                        string groutingBatchNo = data["groutingBatchNo"] + "";
                        string groutingMouldCode = data["groutingMouldCode"] + "";
                        ServiceResultEntity sre = PDAModuleLogic.GetGroutingMouldByBatchNo(groutingMouldCode, groutingLineCode, groutingDay, groutingBatchNo);
                        if (sre.Status == Constant.ServiceResultStatus.Success)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Result);
                            actionResult.Message = sre.Message;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = sre.OtherStatus;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }
                }
                #endregion
                #region 3#半检一检交坯
                else if (module == "SemiQualityStatistics")
                {
                    if (action == "SemiQualityStatisticsDeliver3")
                    {
                        ServiceResultEntity sre = PMModuleLogicDAL.SemiQualityStatisticsDeliver3(data, sUserInfo);

                        if (sre.OtherStatus < 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }

                        return actionResult;
                    }
                }
                #endregion

                #region 产品分级（3车间）
                else if (module == "0628")
                {
                    if (action == "CheckOneLevelType")
                    {
                        string barcode = data["Barcode"] + "";
                        ServiceResultEntity sre = PDAModuleLogic.CheckOneLevelType(barcode);

                        if (sre.OtherStatus < 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(sre.Data.Tables[0]);
                        }

                        return actionResult;
                    }

                    if (action == "SaveOneLevelType")
                    {
                        int? levelTypeID = data["LevelTypeID"].ToNullableInt32();
                        string barcode = data["Barcode"] + "";

                        ServiceResultEntity sre = PDAModuleLogic.SaveOneLevelType(levelTypeID, barcode);

                        if (sre.OtherStatus < 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                        }

                        return actionResult;
                    }
                }
                #endregion

                #region 半检查询责任工序（3车间）
                else if (module == "GetDutyProcedureByBarCode3")
                {
                    if (action == "GetDutyProcedureByBarCode3")
                    {
                        string barcode = data["barcode"] + "";
                        int defectid = Convert.ToInt32(data["defectid"] + "");
                        int procedureid = Convert.ToInt32(data["procedureid"] + "");

                        DataSet dutyProcedureDs = ServiceInvoker.Invoke<DataSet>(this,
                            () => PMModuleLogic.GetDutyProcedureByBarCode(barcode, defectid, sUserInfo.AccountID, procedureid));

                        if (dutyProcedureDs != null)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Result = JsonHelper.ToJson(dutyProcedureDs);

                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                        }

                        return actionResult;
                    }
                }
                #endregion

                #region 成品检验
                if (module == "ProductionData")
                {
                    //扫码查询
                    if (action == "CheckBarcode")
                    {
                        string barcode = data["barcode"] + "";

                        ServiceResultEntity sre = Service.PCModuleService.FinishedCheckLogic.GetProductionID(barcode);

                        int procedureID = Convert.ToInt32(sre.Data.Tables[0].Rows[0]["finishedcheckprocedureid"]);


                        sre = Service.PCModuleService.FinishedCheckLogic.CheckBarcode(procedureID, barcode, sUserInfo);


                        //actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                        if (Convert.ToInt32(sre.Result) < 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = sre.OtherStatus; //漏扫1,反之0
                            actionResult.Message = sre.Message;
                        }
                        else
                        {
                            actionResult.Result = JsonHelper.ToJson(sre.Data);
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }

                    //撤销查询
                    if (action == "GetFinishedCancleData")
                    {
                        string barcode = data["barcode"] + "";

                        ServiceResultEntity sre = Service.PCModuleService.FinishedCheckLogic.GetFinishedCancleData(barcode, sUserInfo);

                        //actionResult.Result = JsonHelper.ToJson(Convert.ToInt32(resultEntity.Result));
                        if (Convert.ToInt32(sre.Result) < 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = sre.OtherStatus; //漏扫1,反之0
                            actionResult.Message = sre.Message;
                        }
                        else
                        {
                            actionResult.Result = JsonHelper.ToJson(sre.Data);
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }

                    //保存成品检验
                    if (action == "AddCheckBarcode")
                    {
                        int procedureID = Convert.ToInt32(data["procedureID"]);
                        //DataTable TableProductionData = JsonHelper.FromJson<DataTable>(data["productionData"] + "");
                        //缺陷
                        //DataTable productionDefectTable = JsonHelper.FromJson<DataTable>(data["productionDefectTable"] + "");
                        //责任员工
                        //DataTable DSTableStaff = JsonHelper.FromJson<DataTable>(data["dSTableStaff"] + "");
                        //漏检员工
                        //DataTable DSTableMissedStaff = JsonHelper.FromJson<DataTable>(data["dSTableMissedStaff"] + "");
                        //图片
                        //DataTable DSTableImage = JsonHelper.FromJson<DataTable>(data["dSTableImage"] + "");

                        //ProductionDataEntity[] productionDataEntitys = new ProductionDataEntity[TableProductionData.Rows.Count];
                        #region 转换实体
                        //for (int i = 0; i < TableProductionData.Rows.Count; i++)
                        //{
                        //	if (TableProductionData.Rows[i]["ReadOnly"].ToString() == "1") //只读数据不进行保存
                        //	{
                        //		continue;
                        //	}

                        //	ProductionDataEntity productionDataEntity = new ProductionDataEntity();
                        //	if (TableProductionData.Rows[i]["ProductionDataID"].ToString() != "")
                        //	{
                        //		productionDataEntity.ProductionDataID = Convert.ToInt32(TableProductionData.Rows[i]["ProductionDataID"]);
                        //	}
                        //	productionDataEntity.Barcode = TableProductionData.Rows[i]["BarCode"].ToString();
                        //	productionDataEntity.UserID = sUserInfo.UserID;
                        //	productionDataEntity.UserCode = sUserInfo.UserCode;
                        //	productionDataEntity.UserName = sUserInfo.UserName; ;
                        //	productionDataEntity.DefectFlag = Convert.ToInt32(TableProductionData.Rows[i]["GoodsLevelTypeID"]) == 4 ? 1 : 2;
                        //	productionDataEntity.GoodsLevelID = Convert.ToInt32(TableProductionData.Rows[i]["DefectFlagID"]);
                        //	productionDataEntity.GoodsLevelTypeID = Convert.ToInt32(TableProductionData.Rows[i]["GoodsLevelTypeID"]);
                        //	productionDataEntity.Remarks = TableProductionData.Rows[i]["Remarks"].ToString();
                        //	if (TableProductionData.Rows[i]["LogoID"].ToString() != "")
                        //	{
                        //		productionDataEntity.LogoID = Convert.ToInt32(TableProductionData.Rows[i]["LogoID"]);
                        //	}

                        //	if (TableProductionData.Rows[i]["OPTimeStamp"].ToString() != "")
                        //	{
                        //		productionDataEntity.OPTimeStamp = Convert.ToDateTime(TableProductionData.Rows[i]["OPTimeStamp"]);
                        //	}

                        //	if (TableProductionData.Rows[i]["CheckTime"].ToString() != "")
                        //	{
                        //		productionDataEntity.CheckTime = Convert.ToDateTime(TableProductionData.Rows[i]["CheckTime"]);
                        //	}
                        //	if (TableProductionData.Rows[i]["OrgGoodsLevelTypeID"].ToString() != "-1")
                        //	{
                        //		productionDataEntity.OrgGoodsLevelTypeID = Convert.ToInt32(TableProductionData.Rows[i]["OrgGoodsLevelTypeID"]);
                        //	}
                        //	if (!string.IsNullOrEmpty(TableProductionData.Rows[i]["ReworkProcedureID"].ToString()))
                        //	{
                        //		productionDataEntity.ReworkProcedureID = int.Parse(TableProductionData.Rows[i]["ReworkProcedureID"].ToString());
                        //		productionDataEntity.IsReworked = 1;
                        //	}
                        //	productionDataEntitys[i] = productionDataEntity;

                        //	List<ProductionDefectEntity> productionDefectEntitys = new List<ProductionDefectEntity>();
                        //	ProductionDefectEntity productionDefectEntity = null;
                        //	for (int j = 0; j < productionDefectTable.Rows.Count; j++) //缺陷列表
                        //	{
                        //		productionDefectEntity = new ProductionDefectEntity();
                        //		productionDefectEntity.SpecialDefect = productionDefectTable.Rows[j]["IsOtherDefect"].ToString();
                        //		//if (productionDefectTable.Rows[j]["DefectDeductionID"].ToString() != "-1"
                        //		//    && productionDefectTable.Rows[j]["DefectDeductionID"].ToString() != string.Empty)
                        //		//{
                        //		//    productionDefectEntity.DefectDeductionNum = Convert.ToDecimal(productionDefectTable.Rows[j]["DefectDeductionNum"]);
                        //		//}
                        //		if (!string.IsNullOrEmpty(productionDefectTable.Rows[j]["DefectDeductionNum"] + ""))
                        //		{
                        //			productionDefectEntity.DefectDeductionNum = Convert.ToDecimal(productionDefectTable.Rows[j]["DefectDeductionNum"]);
                        //		}
                        //		productionDefectEntity.ScrapResponFlag = "0";
                        //		productionDefectEntity.DefectID =
                        //			Convert.ToInt32(productionDefectTable.Rows[j]["DefectID"]);
                        //		productionDefectEntity.DefectCode =
                        //			productionDefectTable.Rows[j]["DefectCode"].ToString();
                        //		productionDefectEntity.DefectName =
                        //			productionDefectTable.Rows[j]["DefectName"].ToString().Replace(productionDefectEntity.DefectCode + "->", "");
                        //		productionDefectEntity.DefectPositionID =
                        //			Convert.ToInt32(productionDefectTable.Rows[j]["DefectPositionID"]);
                        //		productionDefectEntity.DefectPositionCode =
                        //			productionDefectTable.Rows[j]["DefectPositionCode"].ToString();
                        //		productionDefectEntity.DefectPositionName =
                        //			productionDefectTable.Rows[j]["DefectPositionName"].ToString().Replace(productionDefectEntity.DefectPositionCode + "->", "");
                        //		productionDefectEntity.DefectProductionDataID =
                        //			Convert.ToInt32(productionDefectTable.Rows[j]["ProductionDataID"] + "");

                        //		if (productionDefectEntity.DefectProductionDataID == 0)
                        //		{
                        //			productionDefectEntity.DefectProductionDataID = null;
                        //		}
                        //		if (productionDefectTable.Rows[j]["DefectProcedureID"].ToString() != string.Empty &&
                        //			Convert.ToInt32(productionDefectTable.Rows[j]["DefectProcedureID"] + "") > Constant.INT_IS_ZERO)
                        //		{
                        //			productionDefectEntity.DefectProcedureID =
                        //				Convert.ToInt32(productionDefectTable.Rows[j]["DefectProcedureID"]);
                        //		}
                        //		productionDefectEntity.DefectProcedureCode =
                        //			productionDefectTable.Rows[j]["DefectProcedureCode"].ToString();
                        //		productionDefectEntity.DefectProcedureName =
                        //			productionDefectTable.Rows[j]["DefectProcedureName"].ToString();
                        //		productionDefectEntity.DefectUserID =
                        //			Convert.ToInt32(productionDefectTable.Rows[j]["DefectUserID"]);
                        //		productionDefectEntity.DefectUserCode =
                        //			productionDefectTable.Rows[j]["DefectUserCode"].ToString();
                        //		productionDefectEntity.DefectUserName =
                        //			productionDefectTable.Rows[j]["DefectUserName"].ToString();
                        //		productionDefectEntity.DefectJobs =
                        //			Convert.ToInt32(productionDefectTable.Rows[j]["Jobs"].ToString());
                        //		productionDefectEntity.Remarks =
                        //				productionDefectTable.Rows[j]["DefectRemarks"].ToString();
                        //		productionDefectEntity.Remarks =
                        //				productionDefectTable.Rows[j]["DefectRemarks"].ToString();
                        //		if (productionDefectTable.Rows[j]["DefectFineID"].ToString() != "-1"
                        //			&& productionDefectTable.Rows[j]["DefectFineID"].ToString() != string.Empty)
                        //		{
                        //			productionDefectEntity.DefectFine = Convert.ToInt32(productionDefectTable.Rows[j]["DefectFineID"]);
                        //		}


                        //		if (productionDefectTable.Rows[j]["CheckTime"].ToString() != string.Empty)
                        //		{
                        //			//if (Convert.ToInt32(this.TableProductionData.Rows[i]["OrgGoodsLevelTypeID"]) == Convert.ToInt32(this.TableProductionData.Rows[i]["GoodsLevelTypeID"]))
                        //			//{
                        //			productionDefectEntity.CheckTime = Convert.ToDateTime(productionDefectTable.Rows[j]["CheckTime"]);
                        //			//}

                        //		}

                        //		if (productionDefectTable.Rows[j]["MissedUserID"].ToString() != "-1"
                        //			&& productionDefectTable.Rows[j]["MissedUserID"].ToString() != string.Empty)
                        //		{
                        //			productionDefectEntity.MissedUserID = Convert.ToInt32(productionDefectTable.Rows[j]["MissedUserID"]);
                        //			productionDefectEntity.MissedUserCode = productionDefectTable.Rows[j]["MissedUserCode"].ToString();
                        //			productionDefectEntity.MissedUserName = productionDefectTable.Rows[j]["MissedUserName"].ToString();
                        //		}
                        //		// 遍历责任员工
                        //		List<DefectResponsibleEntity> DefectResponsibles = new List<DefectResponsibleEntity>();
                        //		if (DSTableStaff != null && DSTableStaff.Rows.Count > 0)
                        //		{
                        //			DefectResponsibleEntity defectResponsibleEntity = null; 
                        //			foreach (DataRow drStaff in DSTableStaff.Rows)
                        //			{
                        //				if (Convert.ToInt32(drStaff["IsSelected"]) == Constant.INT_IS_ONE)
                        //				{
                        //					defectResponsibleEntity = new DefectResponsibleEntity();
                        //					defectResponsibleEntity.StaffID = Convert.ToInt32(drStaff["StaffID"]);
                        //					defectResponsibleEntity.UserID = Convert.ToInt32(productionDefectEntity.DefectUserID);
                        //					defectResponsibleEntity.UserCode = productionDefectEntity.DefectUserCode;
                        //					defectResponsibleEntity.UJobsID =
                        //						Convert.ToInt32(productionDefectTable.Rows[j]["Jobs"].ToString());
                        //					defectResponsibleEntity.SJobsID =
                        //						Convert.ToInt32(productionDefectTable.Rows[j]["Jobs"].ToString());
                        //					defectResponsibleEntity.StaffStatus = Convert.ToInt32(drStaff["StaffStatus"]);
                        //					DefectResponsibles.Add(defectResponsibleEntity);
                        //				}
                        //			}
                        //			//productionDefectEntity.DefectResponsibles = DefectResponsibles.ToArray();//每个缺陷对应的责任员工
                        //			productionDefectEntity.DefectResponsibles = DefectResponsibles;//每个缺陷对应的责任员工
                        //		} 
                        //		// 遍历漏检责任员工
                        //		List<DefectMissedResponsibleEntity> DefectMissedResponsibles = new List<DefectMissedResponsibleEntity>();
                        //                          if (DSTableMissedStaff != null && DSTableMissedStaff.Rows.Count > 0)
                        //                          {
                        //                              DefectMissedResponsibleEntity defectMissedResponsibleEntity = null; 
                        //			foreach (DataRow drStaff in DSTableMissedStaff.Rows)
                        //			{
                        //				if (Convert.ToInt32(drStaff["IsSelected"]) == Constant.INT_IS_ONE)
                        //				{
                        //					defectMissedResponsibleEntity = new DefectMissedResponsibleEntity();
                        //					defectMissedResponsibleEntity.StaffID = Convert.ToInt32(drStaff["StaffID"]);
                        //					defectMissedResponsibleEntity.UserID = Convert.ToInt32(productionDefectEntity.DefectUserID);
                        //					defectMissedResponsibleEntity.UserCode = productionDefectEntity.DefectUserCode;
                        //					defectMissedResponsibleEntity.UJobsID = Convert.ToInt32(drStaff["UJobsID"]);
                        //					defectMissedResponsibleEntity.SJobsID = Convert.ToInt32(drStaff["SJobsID"]);
                        //					defectMissedResponsibleEntity.StaffStatus = Convert.ToInt32(drStaff["StaffStatus"]);
                        //					DefectMissedResponsibles.Add(defectMissedResponsibleEntity);
                        //				}
                        //			}
                        //			//productionDefectEntity.DefectMissedResponsibles = DefectMissedResponsibles.ToArray();
                        //			productionDefectEntity.DefectMissedResponsibles = DefectMissedResponsibles;
                        //		}
                        //                          // 遍历缺陷图片
                        //                          if (DSTableImage != null && DSTableImage.Rows.Count > 0)
                        //                          {

                        //                              List<DefectImageEntity> defectImageEntitys = new List<DefectImageEntity>();
                        //			DefectImageEntity defectImageEntity = null; 
                        //			foreach (DataRow drImage in DSTableImage.Rows)
                        //			{
                        //				defectImageEntity = new DefectImageEntity();
                        //				defectImageEntity.Thumbnail = (byte[])drImage["ImageByte"];
                        //				defectImageEntity.Image = (byte[])drImage["orgImageByte"];
                        //				defectImageEntitys.Add(defectImageEntity);
                        //			} 
                        //			productionDefectEntity.DefectImages = defectImageEntitys;
                        //		}
                        //		productionDefectEntitys.Add(productionDefectEntity);
                        //	} 
                        //	productionDataEntitys[i].ProductionDefects = productionDefectEntitys;
                        //	}
                        #endregion

                        ProductionDataEntity[] productionDataEntitys = JsonHelper.FromJson<ProductionDataEntity[]>(data["productionDataEntitys"] + "");

                        DataTable bomDetailTable = new DataTable();

                        if (data["bomDetailTable"] != null)
                        {
                            bomDetailTable = JsonHelper.FromJson<DataTable>(data["bomDetailTable"] + "");
                        }
                        ServiceResultEntity sre = Service.PCModuleService.FinishedCheckLogic.AddCheckBarcode(procedureID, productionDataEntitys, bomDetailTable, sUserInfo);


                        if (Convert.ToInt32(sre.Result) > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Message = "保存成功";
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }

                    //撤销
                    if (action == "FinishedCancleData")
                    {
                        int productionDataID = Convert.ToInt32(data["productionDataID"]);

                        ServiceResultEntity sre = Service.PCModuleService.FinishedCheckLogic.FinishedCancleData(productionDataID, sUserInfo);


                        if (Convert.ToInt32(sre.OtherStatus) > 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Message = "撤销成功";
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }

                    //查询用户
                    if (action == "CheckProcedureUser")
                    { 
                        string userCode1 = data["UserCode"] + "";

                        ServiceResultEntity sre = Service.PCModuleService.FinishedCheckLogic.CheckProcedureUser(userCode1, sUserInfo);


                        if (Convert.ToInt32(sre.Result) < 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Result = sre.OtherStatus; 
                            actionResult.Message = sre.Message;
                        }
                        else
                        {
                            actionResult.Result = JsonHelper.ToJson(sre.Data);
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Message = sre.Message;
                        }
                        return actionResult;
                    }

                }
                #endregion

                #region BPM同步日志 add xiacm 2022-11-17
                else if (module == "BARCODEIDNRKSCRAP")
                {
                    if (action == "GetBarcodeIdnrkScrap")
                    {
                        //组件唯一编码
                        string IdnrkOnlyCode = data["IdnrkOnlyCode"].ToString();

                        // 确认日期
                        DateTime createTime = DateTime.Now.Date;
                        if (data.ContainsKey("CreateTime") && !string.IsNullOrEmpty(data["CreateTime"] + ""))
                        {
                            createTime = Convert.ToDateTime(data["CreateTime"].ToString());
                        }

                        // 确认标识(1:确认；2：撤销)
                        string confirmFlag = data["ConfirmFlag"].ToString();
                        string message = string.Empty;

                        DataSet IdnrkOnlyCodeDs = ServiceInvoker.Invoke(this,
                           () => PMModuleLogic.GetIdnrkOnlyCode(IdnrkOnlyCode, createTime, confirmFlag, sUserInfo, out message));

                        if (IdnrkOnlyCodeDs != null)
                        {
                            if (string.IsNullOrEmpty(message))
                            {
                                actionResult.Status = (int)Constant.PDAResult.Success;
                                actionResult.Result = JsonHelper.ToJson(IdnrkOnlyCodeDs);
                            }
                            else
                            {
                                actionResult.Status = (int)Constant.PDAResult.Fail;
                                actionResult.Message = message;
                            }
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = message;
                        }

                        return actionResult;
                    }

                    if (action == "ConfirmBarcodeIdnrkScrap")
                    {
                        ClientRequestEntity cre = new ClientRequestEntity();
                        DataTable dtBarcodeIdnrkScrap = JsonHelper.FromJson<DataTable>(data["Table1"] + "");

                        DateTime createTime = DateTime.Now.Date;

                        if (data.ContainsKey("CreateTime") && !string.IsNullOrEmpty(data["CreateTime"] + ""))
                        {
                            createTime = Convert.ToDateTime(data["CreateTime"].ToString());
                        }

                        cre.Data = new DataSet();
                        cre.Data.Tables.Add(dtBarcodeIdnrkScrap);
                        // 确认日期
                        cre.Properties["CreateTime"] = createTime;
                        // 确认标识(1:确认；2：撤销)
                        cre.Properties["ConfirmFlag"] = data["ConfirmFlag"].ToString();

                        if (dtBarcodeIdnrkScrap != null && dtBarcodeIdnrkScrap.Rows.Count > 0)
                        {
                            ServiceResultEntity sre = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                                () => PMModuleLogic.ConfirmBarcodeIdnrkScrap(cre, sUserInfo));

                            if (Convert.ToInt32(sre.Result) <= 0)
                            {
                                actionResult.Status = (int)Constant.PDAResult.Fail;
                                actionResult.Message = sre.Message;
                            }
                            else
                            {
                                actionResult.Status = (int)Constant.PDAResult.Success;
                                actionResult.Message = "保存成功";
                            }
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                        }
                        return actionResult;
                    }

                }
                #endregion

                #region 次品扫描功能 20230406 by qq
                if (module == "Recycling")
                {
                    //扫码查询
                    if (action == "RecyclingAddBarcode")
                    {
                        string barcode = data["barcode"] + ""; 
                        string type = data["type"] + "";
                         
                        ServiceResultEntity sre = ServiceInvoker.Invoke<ServiceResultEntity>(this,
                                () => PMModuleLogic.RecyclingAddBarcode(barcode, type, sUserInfo));

                        if (Convert.ToInt32(sre.Result) <= 0)
                        {
                            actionResult.Status = (int)Constant.PDAResult.Fail;
                            actionResult.Message = sre.Message;
                        }
                        else
                        {
                            actionResult.Status = (int)Constant.PDAResult.Success;
                            actionResult.Message = "保存成功";
                        }
                        return actionResult;
                    }
                }

                #endregion

                return actionResult;
            }
            catch (Exception ex)
            {
                //LogFileOperation.Error(DataManager.LogFileName, ex.Message);
                OutputLog.TraceLog(LogPriority.Error,
                                this.ToString(),
                                System.Reflection.MethodBase.GetCurrentMethod().Name + System.Environment.NewLine +
                                JsonHelper.ToJson(sUserInfo) + System.Environment.NewLine +
                                " module:" + module + " action:" + action + " json:" + jsonData,
                                ex.ToString(),
                                LocalPath.LogExePath);
                actionResult.Status = (int)Constant.PDAResult.Exception;
                actionResult.Message = Constant.PDA_RESULT_EXCEPTION;
            }
            return actionResult;
        }

        #endregion
    }
}