HEGII.ss.mes.wcf/DK.Service/PDAModuleLogic/PDAModuleLogicWorkShop3.cs

/*******************************************************************************
 * Copyright(c) 2019 DongkeSoft All rights reserved. / Confidential
 * 类的信息：
 *      1.程序名称：PDAModuleLogicWorkShop3.cs
 *      2.功能描述：PDA相关处理(三车间专用)。
 * 编辑履历：
 *      作者            日期                版本            修改内容
 *      徐伟          2019/11/05            1.00            新建
 *******************************************************************************/

using System;
using System.Collections.Generic;
using System.Data;
using System.Drawing;
using System.Drawing.Imaging;
using System.IO;
using System.Text;

using Dongke.IBOSS.PRD.Basics.BaseResources;
using Dongke.IBOSS.PRD.Basics.DataAccess;
using Dongke.IBOSS.PRD.Basics.Library;
using Dongke.IBOSS.PRD.Service.DataModels;
using Dongke.IBOSS.PRD.WCF.DataModels;
using Dongke.IBOSS.PRD.WCF.DataModels.HRModule;
using Dongke.IBOSS.PRD.WCF.DataModels.PCModule;
using Dongke.IBOSS.PRD.WCF.DataModels.PMModule;
using Oracle.ManagedDataAccess.Client;
using Newtonsoft.Json.Linq;
using Dongke.IBOSS.PRD.Service.CMNModuleService;
using System.Collections;

namespace Dongke.IBOSS.PRD.Service.PDAModuleLogic
{
    /// <summary>
    /// 三车间专用接口
    /// </summary>
    public partial class PDAModuleLogic
    {
        #region xuwei add 2019-10-28 三车间接口
        /// <summary>
        /// 用于方法互调，并且附加返回结果
        /// </summary>
        /// <param name="sre">原SRE</param>
        /// <param name="addSre">添加SRE</param>
        public static void AddServiceResultEntity(ServiceResultEntity sre, ServiceResultEntity addSre)
        {
            for (int i = 0; i < addSre.Data.Tables.Count; i++)
                sre.Data.Tables.Add(addSre.Data.Tables[i].Copy());
            sre.Status = addSre.Status;
            sre.Message = addSre.Message;
        }

        /// <summary>
        /// 替换成型线的当前生产工号 查询方法 ok
        /// </summary>
        /// <param name="groutingLineNo"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity GetGroutingLineUserCode(string groutingLineCode, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            try
            {
                conn.Connect();
                //检查成型线是否存在
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                    SELECT
	                    l.GROUTINGLINECODE, -- AS 成型线编码,
                        c.USERCODE -- AS 用户编码
                    FROM
	                    TP_PC_GROUTINGLINE l 
                        LEFT JOIN TP_MST_USER c ON l.USERID = c.USERID 
                    WHERE
	                    l.VALUEFLAG = '1'
                        AND l.ACCOUNTID = {sUser.AccountID}
	                    AND l.GROUTINGLINECODE = '{groutingLineCode}'
                    ";
                    DataTable groutingLine = conn.GetSqlResultToDt(sqlStr);
                    groutingLine.TableName = "GroutingLine";
                    sre.Data.Tables.Add(groutingLine);
                    if (groutingLine.Rows.Count == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "没有查询结果！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                }
                //检查成型线是否包含当前登录的成型工号
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT
	                        l.GROUTINGLINECODE, -- AS 成型线编码,
                            c.USERCODE -- AS 用户编码
                        FROM
	                        TP_PC_GROUTINGLINE l
	                        INNER JOIN TP_PC_GROUTINGUSER u ON l.GROUTINGLINEID = u.GROUTINGLINEID 
                            LEFT JOIN TP_MST_USER c ON u.USERID = c.USERID 
                        WHERE
	                        l.VALUEFLAG = '1' 
                            AND l.ACCOUNTID = {sUser.AccountID}
                            AND l.GROUTINGLINECODE = '{groutingLineCode}'
                    ";
                    DataTable groutingLineUser = conn.GetSqlResultToDt(sqlStr);
                    groutingLineUser.TableName = "GroutingLineUser";
                    sre.Data.Tables.Add(groutingLineUser);

                    bool isUser = false;
                    for (int i = 0; i < groutingLineUser.Rows.Count; i++)
                        if (groutingLineUser.Rows[i]["USERCODE"].ToString() == sUser.UserCode)
                            isUser = true;
                    if (groutingLineUser.Rows.Count == 0 || !isUser)
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "成型线不包含当前生产工号！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }

        /// <summary>
        /// 替换成型线的当前生产工号 替换方法 ok
        /// </summary>
        /// <param name="groutingLineCode"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity SetGroutingLineUserCode(string groutingLineCode, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            try
            {
                conn.Connect();
                //校验替换合法性
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    AddServiceResultEntity(sre, GetGroutingLineUserCode(groutingLineCode, sUser));
                }
                //替换成型线当前的成型工号
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        UPDATE 
                            TP_PC_GROUTINGLINE 
                        SET 
                            USERID = {sUser.UserID} 
                        WHERE
	                        GROUTINGLINECODE = '{groutingLineCode}'
                            AND ACCOUNTID = {sUser.AccountID}
                    ";
                    int execute = conn.ExecuteNonQuery(sqlStr);
                    if (execute > 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作完成！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.NoModifyData;
                        sre.Message = "操作失败，没有更新任何数据！";
                    }
                    conn.Commit();
                }
            }
            catch (Exception ex)
            {
                conn.Rollback();
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }

        /// <summary>
        /// 成型线注浆批次查询 ok
        /// </summary>
        /// <param name="groutingLineCode"></param>
        /// <param name="groutingDay"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity GetGroutingLineBatchNo(string groutingLineCode, string groutingDay, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            try
            {
                conn.Connect();
                //成型线注浆批次查询
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT DISTINCT
	                        d.GROUTINGBATCHNO --AS 注浆批次 
                        FROM
	                        TP_PM_GROUTINGDAILY d 
                        WHERE
	                        d.VALUEFLAG = '1' 
	                        AND d.ACCOUNTID = {sUser.AccountID} 
	                        AND d.GROUTINGLINECODE = '{groutingLineCode}' 
	                        AND d.GROUTINGDATE = date'{groutingDay}' 
                        ORDER BY
	                        d.GROUTINGBATCHNO
                        ";
                    DataTable GroutingLineBatchNo = conn.GetSqlResultToDt(sqlStr);
                    GroutingLineBatchNo.TableName = "GroutingLineBatchNo";
                    sre.Data.Tables.Add(GroutingLineBatchNo);
                    if (GroutingLineBatchNo.Rows.Count == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "没有查询结果！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }

        /// <summary>
        /// 成型线信息查询 ok
        /// </summary>
        /// <param name="groutingLineCode"></param>
        /// <param name="groutingDay"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity GetGroutingLineInfo(string groutingLineCode, string groutingDay, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            string sqlStrNext = "";
            try
            {
                conn.Connect();
                //成型线注浆查询
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT
	                        1 
                        FROM
	                        TP_MST_USERPURVIEW p
	                        INNER JOIN tp_mst_user u ON u.USERID = p.USERID
                        WHERE
	                        p.PURVIEWTYPE = '6' 
	                        AND ( p.PURVIEWID = - 1 OR p.PURVIEWID = ( SELECT GROUTINGLINEID FROM TP_PC_GROUTINGLINE WHERE GROUTINGLINECODE = '{groutingLineCode}' ) ) 
	                        AND u.USERCODE = '{sUser.UserCode}'
                        ";
                    DataTable purview = conn.GetSqlResultToDt(sqlStr);
                    //purview.TableName = "UserPurview";
                    //sre.Data.Tables.Add(purview);
                    if (purview.Rows.Count == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "用户无权限操作该成型线！";
                    }
                    else
                    {
                        sqlStrNext = $@"
                        SELECT
	                        l.GROUTINGLINECODE ,-- AS 成型线号,
	                        l.LASTGROUTINGDATE ,-- AS 已注浆日期,
	                        l.LASTGROUTINGBATCHNO ,-- AS 已注浆批次,
	                        u.USERCODE ,-- AS 成型工号,
	                        m.USERCODE AS MONITORUSERCODE,-- AS 成型班长,
	                        l.MOULDQUANTITY, -- AS 模具数量, 
	                        t.CANMANYTIMES -- AS 允许多次注浆
                        FROM
	                        TP_PC_GROUTINGLINE l
	                        LEFT JOIN TP_MST_USER u ON l.USERID = u.USERID
	                        LEFT JOIN TP_MST_USER m ON l.USERID = m.USERID
	                        LEFT JOIN TP_MST_GMOULDTYPE t ON l.GMOULDTYPEID = t.GMOULDTYPEID 
                        WHERE
	                        l.VALUEFLAG = '1' --有效标识
                            AND l.ACCOUNTID = {sUser.AccountID}
	                        AND l.GMOULDSTATUS = 1 --成型线正常状态
	                        AND t.CANMANYTIMES = '1' --允许多次注浆
	                        AND EXISTS ( SELECT 1 FROM TP_PC_GROUTINGLINEDETAIL d WHERE l.GROUTINGLINEID = d.GROUTINGLINEID AND d.VALUEFLAG = '1' AND d.GMOULDSTATUS = 1 ) --有正常状态的模具                  
                            AND l.GROUTINGLINECODE = '{groutingLineCode}'
                        ";
                        DataTable groutingLine = conn.GetSqlResultToDt(sqlStrNext);
                        groutingLine.TableName = "GroutingLine";
                        sre.Data.Tables.Add(groutingLine);
                        if (groutingLine.Rows.Count == 0)
                        {
                            sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                            sre.Message = "没有查询结果！";
                        }
                        else
                        {
                            sre.Status = Constant.ServiceResultStatus.Success;
                            sre.Message = "操作成功！";
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }

        /// <summary>
        /// 成型线模具查询方法 E37 2#0101 2019-08-12 应用于 注浆登记
        /// </summary>
        /// <param name="groutingLineCode"></param>
        /// <param name="groutingDay"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity GetGroutingLineDetail(string groutingLineCode, string groutingDay, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            try
            {
                conn.Connect();
                //查找成型线
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    AddServiceResultEntity(sre, GetGroutingLineInfo(groutingLineCode, groutingDay, sUser));
                }
                //校验注浆日期 允许多次注浆：>= 最后注浆日期 不允许多次 > 最后注浆日期 同时小于等于今天
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT
	                        l.LASTGROUTINGDATE,
	                        t.CANMANYTIMES 
                        FROM
	                        TP_PC_GROUTINGLINE l
	                        LEFT JOIN TP_MST_GMOULDTYPE t ON l.GMOULDTYPEID = t.GMOULDTYPEID 
                        WHERE
	                        l.VALUEFLAG = '1'
	                        AND l.ACCOUNTID = {sUser.AccountID} 
                            AND l.GROUTINGLINECODE = '{groutingLineCode}'
                    ";
                    DataTable groutingLine = conn.GetSqlResultToDt(sqlStr);
                    if (groutingLine.Rows.Count>0 && !string.IsNullOrEmpty(groutingLine.Rows[0]["LASTGROUTINGDATE"].ToString()))
                    {
                        DateTime groutingDate = Convert.ToDateTime(groutingDay);
                        DateTime lastGroutingDate = Convert.ToDateTime(groutingLine.Rows[0]["LASTGROUTINGDATE"].ToString());
                        string canManyTimes = groutingLine.Rows[0]["CANMANYTIMES"].ToString();
                        if (!(
                            groutingDate >= lastGroutingDate && canManyTimes == "1" && groutingDate <= DateTime.Now.Date
                            || groutingDate > lastGroutingDate && canManyTimes == "0" && groutingDate <= DateTime.Now.Date
                            ))
                        {
                            sre.Status = Constant.ServiceResultStatus.Other;
                            sre.OtherStatus = -1;
                            sre.Message = "当前日期不允许注浆！";
                        }
                    }
                }
                //检查注浆限制天数 'S_PM_021'
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT
	                        NVL(SETTINGVALUE,'0') 
                        FROM
	                        TP_MST_SYSTEMSETTING
                        WHERE
	                        SETTINGCODE = 'S_PM_021'
                            AND ACCOUNTID = {sUser.AccountID}
                    ";
                    int day = Convert.ToInt32(conn.GetSqlResultToStr(sqlStr));
                    if (day != 0)
                    {
                        DateTime groutingDate = Convert.ToDateTime(groutingDay);
                        DateTime beginDay = DateTime.Now.Date;
                        DateTime endDay = beginDay.AddDays(1 - day);
                        if (groutingDate < endDay || groutingDate > beginDay)
                        {
                            sre.Status = Constant.ServiceResultStatus.Other;
                            sre.OtherStatus = -1;
                            sre.Message = string.Format("允许注浆登记的日期范围【{0:yyyy-MM-dd}】-【{1:yyyy-MM-dd}】", endDay, beginDay);
                        }
                    }
                }
                //成型线模具查询
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT
	                        l.GROUTINGLINECODE,--AS 生产线编号,
	                        d.GROUTINGMOULDCODE,--AS 模具编号,
	                        g.GOODSCODE,--AS 产品编码,
	                        o.LOGONAME--AS 产品商标
                        FROM
	                        TP_PC_GROUTINGLINEDETAIL d
	                        LEFT JOIN TP_PC_GROUTINGLINE l ON l.GROUTINGLINEID = d.GROUTINGLINEID
	                        LEFT JOIN TP_MST_GOODS g ON g.GOODSID = d.GOODSID
	                        LEFT JOIN TP_MST_LOGO o ON o.LOGOID = g.LOGOID
                        WHERE
	                        d.VALUEFLAG = '1' 
	                        AND l.ACCOUNTID = {sUser.AccountID} 
	                        AND d.GMOULDSTATUS = 1 
	                        AND l.GROUTINGLINECODE = '{groutingLineCode}'
                        ORDER BY
	                        d.GROUTINGMOULDCODE
                        ";

                    DataTable groutingLineDetail = conn.GetSqlResultToDt(sqlStr);
                    groutingLineDetail.TableName = "GroutingLineDetail";
                    sre.Data.Tables.Add(groutingLineDetail);
                    if (groutingLineDetail.Rows.Count == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "没有查询结果！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }

        /// <summary>
        /// 成型线注浆查询方法 ok 应用于 注浆编辑
        /// </summary>
        /// <param name="groutingLineCode"></param>
        /// <param name="groutingDay"></param>
        /// <param name="groutingBatchNo"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity GetGroutingLineGrouting(string groutingLineCode, string groutingDay, string groutingBatchNo, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            try
            {
                conn.Connect();
                //查找成型线
                if(sre.Status == Constant.ServiceResultStatus.Success)
                {
                    AddServiceResultEntity(sre, GetGroutingLineInfo(groutingLineCode, groutingDay, sUser));
                }
                //检查注浆限制天数 'S_PM_022'
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT
	                        NVL(SETTINGVALUE,'0') 
                        FROM
	                        TP_MST_SYSTEMSETTING
                        WHERE
	                        SETTINGCODE = 'S_PM_022'
                            AND ACCOUNTID = {sUser.AccountID}
                    ";
                    int day = Convert.ToInt32(conn.GetSqlResultToStr(sqlStr));
                    if (day != 0)
                    {
                        DateTime groutingDate = Convert.ToDateTime(groutingDay);
                        DateTime beginDay = DateTime.Now.Date;
                        DateTime endDay = beginDay.AddDays(1 - day);
                        if (groutingDate < endDay || groutingDate > beginDay)
                        {
                            sre.Status = Constant.ServiceResultStatus.Other;
                            sre.OtherStatus = -1;
                            sre.Message = string.Format("允许注浆编辑的日期范围【{0:yyyy-MM-dd}】-【{1:yyyy-MM-dd}】", endDay, beginDay);
                        }
                    }
                }
                //成型线模具查询
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT
	                        d.GROUTINGDAILYID,-- AS 注浆ID,
                            d.GROUTINGDAILYDETAILID, -- AS 注浆日报明细ID
	                        l.GROUTINGLINECODE,-- AS 生产线编号,
	                        l.LASTGROUTINGDATE,-- AS 最后注浆日期,
	                        l.LASTGROUTINGBATCHNO,-- AS 最后注浆批次,
	                        d.GROUTINGMOULDCODE,-- AS 模具编号,
	                        g.GOODSCODE,-- AS 产品编码,
	                        o.LOGONAME,-- AS 产品商标,
	                        d.GROUTINGFLAG,-- AS 注浆标识,
                            d.NOGROUTINGRREASON AS NOGROUTINGRREASONID, -- 未注浆原因ID
	                        y.DICTIONARYVALUE AS NOGROUTINGRREASON, -- AS 未注浆原因
	                        d.BARCODE,-- AS 绑定条码,
	                        d.SCRAPFLAG -- AS 损坯标识
                        FROM
	                        TP_PM_GROUTINGDAILYDETAIL d	
	                        LEFT JOIN TP_MST_GOODS g ON g.GOODSID = d.GOODSID
	                        LEFT JOIN TP_MST_LOGO o ON o.LOGOID = d.LOGOID
	                        LEFT JOIN TP_PC_GROUTINGLINE l on l.GROUTINGLINEID = d.GROUTINGLINEID 
	                        LEFT JOIN TP_MST_DATADICTIONARY y ON y.DICTIONARYID = d.NOGROUTINGRREASON
                        WHERE
	                        d.VALUEFLAG = '1' 
	                        AND d.ACCOUNTID = {sUser.AccountID} 
	                        AND d.GROUTINGLINECODE = '{groutingLineCode}' 
	                        AND d.GROUTINGDATE = DATE '{groutingDay}' 
	                        AND d.GROUTINGBATCHNO = {groutingBatchNo}
                        ORDER BY
	                        d.GROUTINGMOULDCODE
                        ";

                    DataTable groutingLineDetail = conn.GetSqlResultToDt(sqlStr);
                    groutingLineDetail.TableName = "GroutingLineDetail";
                    sre.Data.Tables.Add(groutingLineDetail);
                    if (groutingLineDetail.Rows.Count == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "没有查询结果！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }

        /// <summary>
        /// 未注浆原因查询方法 TP_MST_DataDictionary.DictionaryType = TPC004 ok
        /// </summary>
        /// <param name="groutingLineCode"></param>
        /// <param name="groutingDay"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity GetGroutingNoGroutingReason(SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            try
            {
                conn.Connect();
                //成型线注浆批次查询
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT
	                        DICTIONARYID,
	                        DISPLAYNO,
                          DICTIONARYVALUE	
                        FROM
	                        TP_MST_DATADICTIONARY 
                        WHERE
	                        VALUEFLAG = '1' 
                            AND ACCOUNTID = {sUser.AccountID}
	                        AND DICTIONARYTYPE = 'TPC004' 
                        ORDER BY
	                        DISPLAYNO
                        ";
                    DataTable GroutingNoGroutingReason = conn.GetSqlResultToDt(sqlStr);
                    GroutingNoGroutingReason.TableName = "GroutingNoGroutingReason";
                    sre.Data.Tables.Add(GroutingNoGroutingReason);
                    if (GroutingNoGroutingReason.Rows.Count == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "没有查询结果！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }

        /// <summary>
        /// 注浆登记保存 ok
        /// </summary>
        /// <param name="groutingData">
            /*
             "groutingData": {
                 "GROUTINGDATE": "注浆日期",
                 "GROUTINGLINECODE": "成型线号",
                 "GROUTINGTIMES": "注浆次数",
                 "GROUTINGLINEDETAIL": [
                     {
                         "GROUTINGMOULDCODE": "注浆模具编1号",
                         "GROUTINGFLAG": "注浆标识1",
                         "NOGROUTINGRREASON": "未注浆原因1"
                     },
                     {
                         "GROUTINGMOULDCODE": "注浆模具编号2",
                         "GROUTINGFLAG": "注浆标识2",
                         "NOGROUTINGRREASON": "未注浆原因2"
                     }
                 ]
             }
             */
        /// </param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity SetGroutingLineDetail(string groutingData, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            int result = -1;
            int classesSettingId = -1;
            string groutingBatchNoBegin = "";
            try
            {
                conn.Connect();
                JObject jsonL = JObject.Parse(groutingData);

                //jsonL["GROUTINGDATE"].ToString(); 注浆日期
                //jsonL["GROUTINGLINECODE"].ToString();成型线号
                //jsonL["GROUTINGTIMES"].ToString();注浆次数

                //注浆批次处理 当注浆日期 等于 当前日期 时 注浆批次 为最后注浆批次 加1 处理
                //当注浆日期 不等于 当前日期 时 注浆批数 从0开始 加1 处理
                //if (DateTime.Now.ToString("yyyy-MM-dd") == jsonL["GROUTINGDATE"].ToString())
                //    groutingBatchNoBegin = "l.LASTGROUTINGBATCHNO";
                //else
                //    groutingBatchNoBegin = "0";

                sqlStr = $@"
                        SELECT
	                        LASTGROUTINGBATCHNO
                        FROM
	                        TP_PC_GROUTINGLINE l
                        WHERE
	                        l.VALUEFLAG = '1' 
                            AND l.ACCOUNTID = {sUser.AccountID}
                            AND l.LASTGROUTINGDATE = DATE '{jsonL["GROUTINGDATE"].ToString()}'
	                        AND l.GROUTINGLINECODE = '{jsonL["GROUTINGLINECODE"].ToString()}'
                        ";
                object obj = conn.GetSqlResultToObj(sqlStr);
                //result = Convert.ToInt32(conn.GetSqlResultToStr(sqlStr));
                if (obj == null || obj == DBNull.Value || Convert.ToInt32(obj) == 0)
                {
                    groutingBatchNoBegin = "0";
                }
                else
                {
                    groutingBatchNoBegin = "l.LASTGROUTINGBATCHNO";
                }

                // TODO 高压自动注浆不验证成型工号
                /*
                //校验工号 成型线工号配置的工号 必须包含当前用户
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT
	                        COUNT(c.USERID)
                        FROM
	                        TP_PC_GROUTINGLINE l
	                        INNER JOIN TP_PC_GROUTINGUSER u ON l.GROUTINGLINEID = u.GROUTINGLINEID
	                        LEFT JOIN TP_MST_USER c ON u.USERID = c.USERID 
                        WHERE
	                        l.VALUEFLAG = '1' 
                            AND l.ACCOUNTID = {sUser.AccountID}
	                        AND l.GROUTINGLINECODE = '{jsonL["GROUTINGLINECODE"].ToString()}'
	                        AND c.USERCODE = '{sUser.UserCode}'
                        ";

                    obj = conn.GetSqlResultToObj(sqlStr);
                    //result = Convert.ToInt32(conn.GetSqlResultToStr(sqlStr));
                    if (obj == null || obj == DBNull.Value || Convert.ToInt32(obj) == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "当前成型线没有配置当前员工！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                }
                */
                //获取是否有班次 设置 classesSettingId
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT 
	                        NVL(MAX(CLASSESSETTINGID),0) AS CLASSESSETTINGID
                        FROM
                            TP_PC_CLASSESSETTING
                        WHERE 
                            ACCOUNTID = {sUser.AccountID}
	                        AND VALUEFLAG = '1'
	                        AND ACCOUNTDATE = DATE '{jsonL["GROUTINGDATE"].ToString()}'
	                        AND USERCODE = '{sUser.UserCode}'
                        ";
                    obj = conn.GetSqlResultToObj(sqlStr);
                    if (obj == null || obj == DBNull.Value || Convert.ToInt32(obj) == 0)
                    {
                        classesSettingId = 0;
                    }
                    else
                    {
                        classesSettingId = Convert.ToInt32(obj);
                    }
                    if (classesSettingId > 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "没有班次配置！";
                    }
                }
                //没有班次的 自动配置班次
                if (classesSettingId == 0)
                {
                    try
                    {
                        //从序列中生成新的班次ID
                        classesSettingId = Convert.ToInt32(
                            conn.GetSqlResultToStr("SELECT SEQ_PC_ClASSESSETTING_ID.NEXTVAL FROM DUAL"));

                        sqlStr = "BEGIN";
                        //插入班次SQL
                        sqlStr += $@"
                            INSERT INTO TP_PC_CLASSESSETTING 
                                ( 
                                    CLASSESSETTINGID, ACCOUNTDATE, USERID, USERCODE, 
                                    ACCOUNTID, CREATEUSERID, UPDATEUSERID 
                                )
                            VALUES 
	                            (
		                            {classesSettingId},-- CLASSESSETTINGID select SEQ_PC_ClASSESSETTING_ID.Nextval FROM DUAL;
		                            to_date('{jsonL["GROUTINGDATE"].ToString()}','yyyy-mm-dd'),-- ACCOUNTDATE
                                    {sUser.UserID},--USERID
		                            '{sUser.UserCode}',-- USERCODE
		                            {sUser.AccountID},--ACCOUNTID
		                            {sUser.UserID},--CREATEUSERID
		                            {sUser.UserID} --UPDATEUSERID
	                            );
                         ";

                        //插入班次详细SQL
                        sqlStr += $@"
                            INSERT INTO TP_PC_CLASSESDETAIL (
	                            CLASSESSETTINGID,ACCOUNTDATE,
	                            USERID,USERCODE,STAFFID,STAFFSTATUS,ACCOUNTID,
	                            VALUEFLAG,CREATEUSERID,UPDATEUSERID,
	                            UJOBSID,SJOBSID,UJOBSNUM 
                            )
                            SELECT
	                            {classesSettingId},--CLASSESSETTINGID 班次ID
		                        to_date('{jsonL["GROUTINGDATE"].ToString()}','yyyy-mm-dd'),-- ACCOUNTDATE
	                            {sUser.UserID},--USERID
	                            '{sUser.UserCode}',--USERCODE
	                            s.STAFFID,--STAFFID
	                            h.STAFFSTATUS,--STAFFSTATUS 员工状态
	                            {sUser.AccountID},--ACCOUNTID
	                            '1',--VALUEFLAG
	                            {sUser.UserID},--CREATEUSERID
	                            {sUser.UserID},--UPDATEUSERID
	                            s.UJOBSID,--UJOBSID 工号工种ID
	                            h.JOBS,--SJOBSID 员工工种ID
	                            ( SELECT COUNT( DISTINCT UJOBSID ) FROM TP_MST_USERSTAFF WHERE USERID = '{sUser.UserID}' ) -- UJOBSNUM 工号工种个数
                            FROM
	                            TP_MST_USERSTAFF s
	                            LEFT JOIN TP_HR_STAFF h ON h.STAFFID = s.STAFFID 
                            WHERE
	                            s.USERID = {sUser.UserID}
                            ;
                        ";
                        sqlStr += "END;";

                        conn.ExecuteNonQuery(sqlStr);
                        //多条语句执行，只返回-1，不报异常就是执行成功
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    catch (Exception ex)
                    {
                        OutputLog.TraceLog(LogPriority.Error,
                                        "",
                                        System.Reflection.MethodBase.GetCurrentMethod().Name,
                                        ex.ToString(),
                                        LocalPath.LogExePath);
                        sre.Status = Constant.ServiceResultStatus.SystemError;
                        sre.Message = "自动配置班次失败！";
                    }
                }
                //插入 注浆记录
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    try
                    {
                        sqlStr = "BEGIN";

                        //按注浆次数循环 保存注浆记录
                        for (int i = 0; i < Convert.ToInt32(jsonL["GROUTINGTIMES"].ToString()); i++)
                        {
                            //获取注浆ID
                            int groutingDailyId = Convert.ToInt32(
                                conn.GetSqlResultToStr(@"SELECT SEQ_PM_GROUTINGDAILY_ID.NEXTVAL FROM DUAL"));

                            //插入注浆记录 TP_PM_GROUTINGDAILY
                            sqlStr += $@"
                            INSERT INTO TP_PM_GROUTINGDAILY (
                                GROUTINGDAILYID,
	                            GROUTINGLINEID,GROUTINGLINECODE,GROUTINGLINENAME,GROUTINGDATE,
                                USERID,MOULDQUANTITY,GMOULDTYPEID,CANMANYTIMES,ACCOUNTID,VALUEFLAG,
	                            CREATEUSERID,UPDATEUSERID,USERCODE,GMOULDSTATUS,
                                CLASSESSETTINGID,GROUTINGBATCHNO,MONITORID,MONITORCODE,HIGHPRESSUREFLAG  
                            ) 
                            SELECT
                                {groutingDailyId},
                                l.GROUTINGLINEID,
                                l.GROUTINGLINECODE,
                                l.GROUTINGLINENAME,
                                DATE '{jsonL["GROUTINGDATE"].ToString()}',-- GROUTINGDATE 注浆日期
                                {sUser.UserID},-- USERID 用户ID
                                l.MOULDQUANTITY,
                                l.GMOULDTYPEID,
                                t.CANMANYTIMES, -- CANMANYTIMES 关联 TP_MST_GMOULDTYPE 查询
                                {sUser.AccountID},-- ACCOUNTID
                                '1',--VALUEFLAG
                                {sUser.UserID},--CREATEUSERID
                                {sUser.UserID},--UPDATEUSERID
                                '{sUser.UserCode}',-- USERCODE
                                l.GMOULDSTATUS,
                                {classesSettingId}, -- 从 CLASSESSETTINGID 查询
                                {groutingBatchNoBegin} + {i} + 1, --LASTGROUTINGBATCHNO 批次号 每注一次加1
                                l.MONITORID,
                                m.USERCODE AS MONITORCODE, --MONITORCODE 关联 TP_MST_USER 查询
                                l.HIGHPRESSUREFLAG
                            FROM
	                            TP_PC_GROUTINGLINE l
	                            LEFT JOIN TP_MST_GMOULDTYPE t ON l.GMOULDTYPEID = t.GMOULDTYPEID
	                            LEFT JOIN TP_MST_USER m ON l.MONITORID = m.USERID
                            WHERE
	                            GROUTINGLINECODE = '{jsonL["GROUTINGLINECODE"].ToString()}' --成型线号
                                AND l.VALUEFLAG = '1'
                                AND l.GMOULDSTATUS = 1
                            ;";

                            //按成型线模具循环插入注浆记录明细 TP_PM_GROUTINGDAILYDETAIL
                            JArray jsonM = JArray.Parse(jsonL["GROUTINGLINEDETAIL"].ToString());
                            for (int j = 0; j < jsonM.Count; j++)
                            {
                                //jsonM[j]["GROUTINGMOULDCODE"].ToString(); 注浆模具编号
                                //jsonM[j]["GROUTINGFLAG"].ToString(); 注浆标识
                                //jsonM[j]["NOGROUTINGRREASON"].ToString(); 未注浆原因

                                //验证注浆原因,如果没给数据，置为空
                                if (!(jsonM[j]["NOGROUTINGRREASON"] is object))
                                    jsonM[j]["NOGROUTINGRREASON"] = "null";

                                //插入注浆记录明细
                                sqlStr += $@"
                                INSERT INTO TP_PM_GROUTINGDAILYDETAIL (
	                                GROUTINGDAILYID,GROUTINGLINEID,GROUTINGLINECODE,GROUTINGLINENAME,GROUTINGLINEDETAILID,
	                                GROUTINGDATE,GROUTINGMOULDCODE,MOULDCODE,GOODSID,GOODSCODE,GOODSNAME,GMOULDSTATUS,
	                                GROUTINGCOUNT,GROUTINGFLAG,NOGROUTINGRREASON,ACCOUNTID,VALUEFLAG,CREATEUSERID,
	                                UPDATEUSERID,USERID,USERCODE,SCRAPFLAG,SPECIALREPAIRFLAG,BARCODE,CLASSESSETTINGID,
	                                ISPUBLICBODY,DELIVERFLAG,GMOULDTYPEID,CANMANYTIMES,GROUTINGBATCHNO,LOGOID,glazetypeid,
	                                SCRAPTIME,SCRAPUSER,SCRAPREASONID,SCRAPREASON,MOULDID,SREASONID,SCRAPTYPE,BEGINNINGFLAG 
                                ) SELECT
                                    {groutingDailyId},--GROUTINGDAILYID
                                    d.GROUTINGLINEID,--GROUTINGLINEID
                                    l.GROUTINGLINECODE,--GROUTINGLINECODE
                                    l.GROUTINGLINENAME,--GROUTINGLINENAME
                                    d.GROUTINGLINEDETAILID,--GROUTINGLINEDETAILID
                                    to_date( '{jsonL["GROUTINGDATE"].ToString()}', 'yyyy-mm-dd' ),--GROUTINGDATE
                                    d.GROUTINGMOULDCODE,--GROUTINGMOULDCODE
                                    d.MOULDCODE,--MOULDCODE
                                    d.GOODSID,--GOODSID
                                    g.GOODSCODE,--GOODSCODE
                                    g.GOODSNAME,--GOODSNAME
                                    d.GMOULDSTATUS,--GMOULDSTATUS
                                    d.GROUTINGCOUNT + {jsonM[j]["GROUTINGFLAG"].ToString()},--GROUTINGCOUNT
                                    '{jsonM[j]["GROUTINGFLAG"].ToString()}',--GROUTINGFLAG
                                    {jsonM[j]["NOGROUTINGRREASON"].ToString()}, --NOGROUTINGRREASON  未注浆原因
                                    {sUser.AccountID},--ACCOUNTID
                                    '1',--VALUEFLAG
                                    {sUser.UserID},--CREATEUSERID
                                    {sUser.UserID},--UPDATEUSERID
                                    {sUser.UserID},--USERID
                                    '{sUser.UserCode}',--USERCODE
                                    '0',--SCRAPFLAG
                                    '0',--SPECIALREPAIRFLAG
                                    null,--BARCODE
                                    {classesSettingId},--CLASSESSETTINGID
                                    '0',--ISPUBLICBODY
                                    '0',--DELIVERFLAG
                                    l.GMOULDTYPEID,--GMOULDTYPEID
                                    t.CANMANYTIMES,--CANMANYTIMES
                                    {groutingBatchNoBegin} + {i} + 1, --LASTGROUTINGBATCHNO 批次号 每注一次加1
                                    o.LOGOID,--LOGOID
                                    g.glazetypeid,
                                    NULL,--SCRAPTIME
                                    NULL,--SCRAPUSER
                                    NULL,--SCRAPREASONID
                                    NULL,--SCRAPREASON
                                    d.MOULDID,--MOULDID
                                    NULL,--SREASONID
                                    NULL,--SCRAPTYPE
                                    '0' --BEGINNINGFLAG
                                FROM
	                                TP_PC_GROUTINGLINEDETAIL d
	                                LEFT JOIN TP_PC_GROUTINGLINE l ON l.GROUTINGLINEID = d.GROUTINGLINEID
	                                LEFT JOIN TP_MST_GOODS g ON g.GOODSID = d.GOODSID
	                                LEFT JOIN TP_MST_LOGO o ON o.LOGOID = g.LOGOID
	                                LEFT JOIN TP_MST_GMOULDTYPE t ON t.GMOULDTYPEID = l.GMOULDTYPEID 
                                WHERE
                                    d.ACCOUNTID = {sUser.AccountID}
	                                AND d.VALUEFLAG = '1' 
	                                AND d.GMOULDSTATUS = 1 
	                                AND l.GROUTINGLINECODE = '{jsonL["GROUTINGLINECODE"].ToString()}' --成型线号
                                    AND d.GROUTINGMOULDCODE = '{jsonM[j]["GROUTINGMOULDCODE"].ToString()}'
                                ;";

                                //更新注浆次数
                                sqlStr += $@"
                                UPDATE 
                                    TP_PC_GROUTINGLINEDETAIL
                                SET 
                                    GROUTINGCOUNT = GROUTINGCOUNT + {jsonM[j]["GROUTINGFLAG"].ToString()}
                                WHERE
                                    ACCOUNTID = {sUser.AccountID}
	                                AND VALUEFLAG = '1' 
	                                AND GMOULDSTATUS = 1 
	                                --AND GROUTINGLINECODE = '{jsonL["GROUTINGLINECODE"].ToString()}' --成型线号
                                    AND GROUTINGMOULDCODE = '{jsonM[j]["GROUTINGMOULDCODE"].ToString()}'
                                ;";

                            }
                            sre.Result = groutingDailyId;
                        }
                        sqlStr += "END;";

                        result = conn.ExecuteNonQuery(sqlStr);
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    catch (Exception ex)
                    {
                        OutputLog.TraceLog(LogPriority.Error,
                                        "",
                                        System.Reflection.MethodBase.GetCurrentMethod().Name,
                                        ex.ToString(),
                                        LocalPath.LogExePath);
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "注浆记录写入失败！";
                    }
                }
                //更新 成型线 最后注浆日期 注浆批次
                if(sre.Status==Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        UPDATE 
                            TP_PC_GROUTINGLINE l
                        SET 
                            l.LASTGROUTINGDATE = DATE '{jsonL["GROUTINGDATE"].ToString()}',
                            l.LASTGROUTINGBATCHNO = {groutingBatchNoBegin} + {jsonL["GROUTINGTIMES"].ToString()},
                            l.H_BatchIndex = l.H_BatchIndex+1
                        WHERE
                            l.GROUTINGLINECODE = '{jsonL["GROUTINGLINECODE"].ToString()}'
                        ";
                    result = conn.ExecuteNonQuery(sqlStr);
                    if (result > 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "成型线最后注浆日期和注浆批次更新失败！";
                    }
                }
                //提交
                if (sre.Status == Constant.ServiceResultStatus.Success)
                    conn.Commit();
                else
                    conn.Rollback();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }

        /// <summary>
        /// 编辑注浆记录保存 ok
        /// </summary>
        /// <param name="groutingData">
            /*
             "groutingData": [
                 {
                     "GROUTINGDAILYDETAILID": "注浆日报ID1",
                     "GROUTINGFLAG": "注浆标识1",
                     "NOGROUTINGRREASON": "未注浆原因1"
                 },
                 {
                     "GROUTINGDAILYDETAILID": "注浆日报ID2",
                     "GROUTINGFLAG": "注浆标识2",
                     "NOGROUTINGRREASON": "未注浆原因2"
                 }
             ]
             */
        /// </param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity SetGroutingLineGrouting(string groutingData, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            int result = 0;
            try
            {
                conn.Connect();
                //一定要先更新注浆次数 如果先更新的注浆记录 将无法分辨 注浆标识
                //更新 成型线明细 注浆日报明细 注浆次数
                if (sre.Status == Constant.ServiceResultStatus.Success && groutingData != "")
                {
                    try
                    {
                        JArray json = JArray.Parse(groutingData);
                        string updateOne = $@"
                            UPDATE 
                                TP_PC_GROUTINGLINEDETAIL
                            SET 
                                GROUTINGCOUNT = GROUTINGCOUNT + :GROUTINGCOUNT
                            WHERE 
                                GROUTINGLINEDETAILID = :GROUTINGLINEDETAILID
                            ;
                            UPDATE 
                                TP_PM_GROUTINGDAILYDETAIL
                            SET 
                                GROUTINGCOUNT = GROUTINGCOUNT + :GROUTINGCOUNT
                            WHERE 
                                GROUTINGDAILYDETAILID = :GROUTINGDAILYDETAILID
                            ;
                            ";
                        sqlStr = "BEGIN";
                        DataTable dt = new DataTable();
                        for (int i = 0; i < json.Count; i++)
                        {
                            //读取原注浆记录进行比对，原来 注浆标识 为1 现在 注浆标识 为0 要-1  反之加1
                            dt = conn.GetSqlResultToDt($@"
                                SELECT  
                                    GROUTINGDAILYDETAILID,
                                    GROUTINGLINEDETAILID,
                                    GROUTINGFLAG
                                FROM
                                    TP_PM_GROUTINGDAILYDETAIL
                                WHERE
                                    GROUTINGDAILYDETAILID = {json[i]["GROUTINGDAILYDETAILID"].ToString()}
                            ");
                            string groutingCount = "";

                            //注浆标识改变 才更新 注浆次数
                            if (json[i]["GROUTINGFLAG"].ToString() != dt.Rows[0]["GROUTINGFLAG"].ToString())
                            {
                                groutingCount = json[i]["GROUTINGFLAG"].ToString() == "1" ? "1" : "-1";
                                sqlStr += updateOne
                                    .Replace(":GROUTINGCOUNT", groutingCount)
                                    .Replace(":GROUTINGLINEDETAILID", dt.Rows[0]["GROUTINGLINEDETAILID"].ToString())
                                    .Replace(":GROUTINGDAILYDETAILID", dt.Rows[0]["GROUTINGDAILYDETAILID"].ToString());
                            }
                        }
                        sqlStr += "END;";
                        result = conn.ExecuteNonQuery(sqlStr);
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    catch
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "注浆次数更新失败！";
                    }
                }
                //更新注浆记录数据 不可以在更新 注浆次数 之前 执行
                if (sre.Status == Constant.ServiceResultStatus.Success && groutingData != "")
                {
                    try
                    {
                        JArray json = JArray.Parse(groutingData);
                        string updateOne = $@"
                            UPDATE 
                                TP_PM_GROUTINGDAILYDETAIL
                            SET
                                GROUTINGFLAG = ':GROUTINGFLAG',
                                NOGROUTINGRREASON = :NOGROUTINGRREASON
                            WHERE
                                GROUTINGDAILYDETAILID = :GROUTINGDAILYDETAILID
                            ;
                            ";
                        sqlStr = "BEGIN";
                        for (int i=0;i<json.Count;i++)
                        {
                            //验证注浆原因,如果没给数据，置为空
                            if (!(json[i]["NOGROUTINGRREASON"] is object))
                                json[i]["NOGROUTINGRREASON"] = "null";

                            sqlStr += updateOne
                                .Replace(":GROUTINGFLAG", json[i]["GROUTINGFLAG"].ToString())
                                .Replace(":NOGROUTINGRREASON", json[i]["NOGROUTINGRREASON"].ToString())
                                .Replace(":GROUTINGDAILYDETAILID", json[i]["GROUTINGDAILYDETAILID"].ToString());
                            //sqlStr += ";";
                        }
                        sqlStr += "END;";
                        result = conn.ExecuteNonQuery(sqlStr);
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    catch
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "注浆记录保存失败！";
                    }
                }

                //提交
                if (sre.Status == Constant.ServiceResultStatus.Success)
                    conn.Commit();
                else
                    conn.Rollback();
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }

        /// <summary>
        /// 模具注浆批次查询 ok
        /// </summary>
        /// <param name="groutingMouldCode"></param>
        /// <param name="groutingDay"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity GetGroutingMouldBatchNo(string groutingMouldCode, string groutingDay, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            try
            {
                conn.Connect();
                //成型线注浆批次查询
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT DISTINCT
	                        d.GROUTINGBATCHNO --AS 注浆批次
                        FROM
	                        TP_PM_GROUTINGDAILYDETAIL d 
                        WHERE
	                        d.VALUEFLAG = '1' 
	                        AND d.ACCOUNTID = {sUser.AccountID} 
	                        AND d.GROUTINGMOULDCODE = '{groutingMouldCode}' 
	                        AND d.GROUTINGDATE = DATE '{groutingDay}' 
                        ORDER BY
	                        d.GROUTINGBATCHNO DESC
                        ";
                    DataTable GroutingMouldBatchNo = conn.GetSqlResultToDt(sqlStr);
                    GroutingMouldBatchNo.TableName = "GroutingMouldBatchNo";
                    sre.Data.Tables.Add(GroutingMouldBatchNo);
                    if (GroutingMouldBatchNo.Rows.Count == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "没有查询结果！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }

        /// <summary>
        /// 模具注浆查询 ok
        /// </summary>
        /// <param name="groutingMouldCode"></param>
        /// <param name="groutingDay"></param>
        /// <param name="groutingBatchNo"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity GetGroutingMouldGrouting(string groutingMouldCode, string groutingDay, string groutingBatchNo, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            try
            {
                conn.Connect();
                //模具注浆查询
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT
	                        d.GROUTINGDAILYID , --AS 注浆ID,
                            d.GROUTINGDAILYDETAILID, -- AS 注浆日报明细ID
                            d.GROUTINGBATCHNO ,-- AS 注浆批次,
	                        m.USERCODE ,-- AS 成型工号,
	                        m.MONITORCODE ,-- AS 成型班长,
	                        d.GROUTINGMOULDCODE,-- AS 模具编号,
	                        g.GOODSCODE,-- AS 产品编码,
	                        o.LOGONAME,-- AS 产品商标,
	                        d.GROUTINGFLAG,-- AS 注浆标识,
                            d.NOGROUTINGRREASON AS NOGROUTINGRREASONID, -- 未注浆原因ID
	                        y.DICTIONARYVALUE AS NOGROUTINGRREASON, -- AS 未注浆原因
	                        d.BARCODE,-- AS 绑定条码,
	                        d.SCRAPFLAG,-- AS 损坯标识,
                            d.BEGINNINGFLAG -- AS 在产标识
                        FROM
	                        TP_PM_GROUTINGDAILYDETAIL d	
	                        LEFT JOIN TP_MST_GOODS g ON g.GOODSID = d.GOODSID
	                        LEFT JOIN TP_MST_LOGO o ON o.LOGOID = d.LOGOID
	                        LEFT JOIN TP_PM_GROUTINGDAILY m ON m.GROUTINGDAILYID = d.GROUTINGDAILYID
	                        LEFT JOIN TP_MST_DATADICTIONARY y ON y.DICTIONARYID = d.NOGROUTINGRREASON
                        WHERE
	                        d.VALUEFLAG = '1' 
	                        AND d.ACCOUNTID = {sUser.AccountID} 
	                        AND d.GROUTINGMOULDCODE = '{groutingMouldCode}' 
	                        AND d.GROUTINGDATE = DATE '{groutingDay}' 
                        ";

                    //如果指定批次号查询指定批次
                    if (!string.IsNullOrEmpty(groutingBatchNo)) sqlStr += $@" AND d.GROUTINGBATCHNO = {groutingBatchNo}";

                    DataTable GroutingMouldDetail = conn.GetSqlResultToDt(sqlStr);
                    GroutingMouldDetail.TableName = "GroutingMouldDetail";
                    sre.Data.Tables.Add(GroutingMouldDetail);
                    if (GroutingMouldDetail.Rows.Count == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "没有查询结果！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }

        /// <summary>
        /// 读取下一个模具注浆信息 ok
        /// </summary>
        /// <param name="groutingMouldCode"></param>
        /// <param name="groutingDay"></param>
        /// <param name="groutingBatchNo"></param>
        /// <param name="groutingMouldCode"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity GetGroutingMouldGroutingNext(string groutingMouldCode, string groutingDay, string groutingBatchNo, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            //string sqlStr = "";
            string groutingMouldCodeNext = ""; //下一个模具号
            try
            {
                conn.Connect();
                //读取模具批次列表
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    AddServiceResultEntity(sre, GetGroutingMouldBatchNo(groutingMouldCode, groutingDay, sUser));
                }
                //读取模具列表 记录下一个模具号 读最后一个时 返回第一个
                //读取条件 注浆的 未报损的 无码的
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    //sqlStr = $@"
                    //    SELECT
                    //     d.GROUTINGMOULDCODE -- AS 模具编号
                    //    FROM
                    //     TP_PM_GROUTINGDAILYDETAIL d
                    //     LEFT JOIN TP_PC_GROUTINGLINE l ON l.GROUTINGLINEID = d.GROUTINGLINEID 
                    //    WHERE
                    //     d.VALUEFLAG = '1' 
                    //     AND d.ACCOUNTID = {sUser.AccountID} 
                    //     AND d.GROUTINGLINECODE = ( SELECT GROUTINGLINECODE FROM TP_PM_GROUTINGDAILYDETAIL WHERE GROUTINGMOULDCODE = '{groutingMouldCode}' AND GROUTINGDATE = DATE '{groutingDay}' AND GROUTINGBATCHNO = {groutingBatchNo}  and valueflag = '1' ) 
                    //     AND d.GROUTINGDATE = DATE '{groutingDay}' 
                    //     AND d.GROUTINGBATCHNO = {groutingBatchNo}
                    //        AND d.GROUTINGFLAG = '1' -- 注浆标识
                    //        AND d.SCRAPFLAG = '0'  -- 损坯标识
                    //        AND d.BARCODE is null
                    //    ";

                    string sqlString = "SELECT D.GROUTINGMOULDCODE -- AS 模具编号\n" +
                    "  FROM TP_PM_GROUTINGDAILYDETAIL D\n" +
                    "  LEFT JOIN TP_PC_GROUTINGLINE L\n" +
                    "    ON L.GROUTINGLINEID = D.GROUTINGLINEID\n" +
                    " WHERE D.VALUEFLAG = '1'\n" +
                    "   AND D.ACCOUNTID = :ACCOUNTID\n" +
                    "   AND D.GROUTINGLINEID = (SELECT MAX(GROUTINGLINEID)\n" +
                    "                             FROM TP_PC_GROUTINGLINEDETAIL GL\n" +
                    "                            WHERE GL.GROUTINGMOULDCODE = :GROUTINGMOULDCODE\n" +
                    "                              AND GL.VALUEFLAG = '1')\n" +
                    "   AND D.GROUTINGDATE = :GROUTINGDATE\n" +
                    "   AND D.GROUTINGBATCHNO = :GROUTINGBATCHNO\n" +
                    "   AND D.GROUTINGFLAG = '1' -- 注浆标识\n" +
                    "   AND D.SCRAPFLAG = '0' -- 损坯标识\n" +
                    "   AND D.BARCODE IS NULL\n" +
                    " ORDER BY D.GROUTINGMOULDCODE";

                    OracleParameter[] ps = new OracleParameter[]
                        {
                            new OracleParameter("ACCOUNTID", sUser.AccountID),
                            new OracleParameter("GROUTINGMOULDCODE", groutingMouldCode),
                            new OracleParameter("GROUTINGDATE", Convert.ToDateTime(groutingDay)),
                            new OracleParameter("GROUTINGBATCHNO", Convert.ToInt32(groutingBatchNo)),
                        };

                    DataTable GroutingMouldCodeList = conn.GetSqlResultToDt(sqlString, ps);
                    //GroutingMouldCodeList.TableName = "GroutingMouldCodeList";
                    //sre.Data.Tables.Add(GroutingMouldCodeList);

                    if (GroutingMouldCodeList.Rows.Count == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "没有查询结果！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";

                        //查找下一个模具号
                        groutingMouldCodeNext = GroutingMouldCodeList.Rows[0]["GROUTINGMOULDCODE"].ToString();
                        for (int i = 0; i < GroutingMouldCodeList.Rows.Count; i++)
                        {
                            if (string.Compare(GroutingMouldCodeList.Rows[i]["GROUTINGMOULDCODE"].ToString(), groutingMouldCode) > 0)
                            {
                                groutingMouldCodeNext = GroutingMouldCodeList.Rows[i]["GROUTINGMOULDCODE"].ToString();
                                break;
                            }
                        }

                    }
                }
                //读取下一个模具信息
                if (sre.Status == Constant.ServiceResultStatus.Success && groutingMouldCodeNext != "")
                {
                    //读取模具信息
                    AddServiceResultEntity(sre, GetGroutingMouldGrouting(groutingMouldCodeNext, groutingDay, groutingBatchNo, sUser));
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }

        /// <summary>
        /// 绑定条码 id 26219 barcode 8000027063
        /// </summary>
        /// <param name="groutingDailyDetailId"></param>
        /// <param name="barCode"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity BindGroutingBarCode(string groutingDailyDetailId, string barCode, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            int result = -1;
            try
            {
                conn.Connect();
                int gl_id = Convert.ToInt32(conn.GetSqlResultToStr($"select g.groutinglineid from tp_pm_groutingdailydetail g where g.GROUTINGDAILYDETAILID = {groutingDailyDetailId}"));

                //检查注浆限制天数 'S_PM_023'
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    //读取注浆日期
                    sqlStr = $@"
                        SELECT
	                        to_char( GROUTINGDATE, 'yyyy-mm-dd' ) 
                        FROM
	                        TP_PM_GROUTINGDAILYDETAIL 
                        WHERE
	                        GROUTINGDAILYDETAILID = {groutingDailyDetailId}
                    ";
                    string groutingDay = conn.GetSqlResultToStr(sqlStr);
                    //读取限定日期
                    sqlStr = $@"
                        SELECT
	                        NVL(SETTINGVALUE,'0') 
                        FROM
	                        TP_MST_SYSTEMSETTING
                        WHERE
	                        SETTINGCODE = 'S_PM_023'
                            AND ACCOUNTID = {sUser.AccountID}
                    ";
                    int day = Convert.ToInt32(conn.GetSqlResultToStr(sqlStr));
                    if (day != 0)
                    {
                        DateTime groutingDate = Convert.ToDateTime(groutingDay);
                        DateTime beginDay = DateTime.Now.Date;
                        DateTime endDay = beginDay.AddDays(1 - day);
                        if (groutingDate < endDay || groutingDate > beginDay)
                        {
                            sre.Status = Constant.ServiceResultStatus.Other;
                            sre.OtherStatus = -1;
                            sre.Message = string.Format("允许绑码的日期范围【{0:yyyy-MM-dd}】-【{1:yyyy-MM-dd}】", endDay, beginDay);
                        }
                    }
                }
                //验证条码是否被使用
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                            SELECT
	                            count( BARCODE ) 
                            FROM
	                            TP_PM_USEDBARCODE 
                            WHERE
	                            ACCOUNTID = {sUser.AccountID} 
	                            AND BARCODE = '{barCode}'
                            ";
                    result = Convert.ToInt32(conn.GetSqlResultToStr(sqlStr));
                    if (result == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.ValidationFailed;
                        sre.Message = "条码已被使用！";
                    }
                }
                //绑定条码处理 写入注浆表 有条码必须先解绑 绑定条件 无码 已注浆 未报损
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                            UPDATE 
                                TP_PM_GROUTINGDAILYDETAIL
                            SET 
                                BARCODE = '{barCode}'
                            WHERE 
                                ACCOUNTID = {sUser.AccountID}
                                AND GROUTINGDAILYDETAILID = {groutingDailyDetailId}
                                AND SCRAPFLAG = '0' -- 损坯不允许绑码
                                AND GROUTINGFLAG = '1' --只有注浆的才可以绑码
                                AND BARCODE IS NULL
                        ";
                    result = conn.ExecuteNonQuery(sqlStr);

                    if (result == 1)
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.NoModifyData;
                        sre.Message = "条码绑定失败！条码重复/未注浆/损坯 不可以绑码！";
                    }
                }
                //绑定条码处理 写入条码使用记录
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        INSERT INTO TP_PM_USEDBARCODE
                            (BARCODE,
                            ACCOUNTID,
                            CREATETIME,
                            CREATEUSERID,
                            GROUTINGDAILYDETAILID,
                            BARCODESTATUS,
                            CLEARFLAG)
                        VALUES
                            (
                            '{barCode}', --条码
                            {sUser.AccountID}, --账套
                            DATE'{DateTime.Now.ToString("yyyy-MM-dd")}', --创建时间
                            {sUser.UserID}, --创建人
                            {groutingDailyDetailId}, --注浆ID
                            1, --注浆
                            0  --正常
                            )
                        ";
                    result = conn.ExecuteNonQuery(sqlStr);

                    if (result == 1)
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.NoModifyData;
                        sre.Message = "条码使用记录写入失败！";
                    }
                }
                //提交
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    conn.Commit();
                }
                else
                {
                    conn.Rollback();
                    return sre;
                }

                // 写入放行PLC
                Hashtable plcPara = new Hashtable();
                plcPara.Add("finishflag", 1);
                ServiceResultEntity sre_plc = PLCModuleLogic.PlcWrite_GL(3501, gl_id, plcPara, sUser.UserCode);
            }
            catch (Exception ex)
            {
                conn.Rollback();
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }

        /// <summary>
        /// 解绑条码 id 26219 barcode 8000027063
        /// </summary>
        /// <param name="groutingDailyDetailId"></param>
        /// <param name="barCode"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity UnBindGroutingBarCode(string groutingDailyDetailId, string barCode, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            int result = -1;
            try
            {
                conn.Connect();
                //判断条码产品是否在产
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                            SELECT 
                                COUNT(GROUTINGDAILYDETAILID) 
                            FROM
                                TP_PM_GROUTINGDAILYDETAIL
                            WHERE 
                                ACCOUNTID = {sUser.AccountID}
                                AND BEGINNINGFLAG = '1'
                                AND GROUTINGDAILYDETAILID = {groutingDailyDetailId}
                        ";
                    result = Convert.ToInt32(conn.GetSqlResultToStr(sqlStr));
                    if(result == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.ValidationFailed;
                        sre.Message = "在产状态的条码不允许解绑！";
                    }
                }
                //解绑条码处理 更新 注资日报表
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    //条码写入注浆表
                    sqlStr = $@"
                            UPDATE 
                                TP_PM_GROUTINGDAILYDETAIL
                            SET 
                                BARCODE = null
                            WHERE 
                                ACCOUNTID = {sUser.AccountID}
                                AND GROUTINGDAILYDETAILID = {groutingDailyDetailId}
                        ";
                    result = conn.ExecuteNonQuery(sqlStr);
                    if (result == 1)
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.NoModifyData;
                        sre.Message = "条码更新失败！";
                    }
                }
                //解绑条码处理 删除 条码使用记录
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                            DELETE 
	                            TP_PM_USEDBARCODE 
                            WHERE 
	                            ACCOUNTID = {sUser.AccountID}
	                            AND BARCODE = '{barCode}'
                                AND GROUTINGDAILYDETAILID = {groutingDailyDetailId}
                        ";
                    result = conn.ExecuteNonQuery(sqlStr);
                    //严谨的逻辑是 result == 1 才对 偶尔存在错误数据，没找到原因，为调试方便改为>=0
                    if (result >= 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.NoModifyData;
                        sre.Message = "条码使用记录删除失败！";
                    }
                }
                //提交
                if (sre.Status == Constant.ServiceResultStatus.Success)
                    conn.Commit();
                else
                    conn.Rollback();
            }
            catch (Exception ex)
            {
                conn.Rollback();
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }

        /// <summary>
        /// 整条成型线解绑条码
        /// </summary>
        /// <param name="groutingLineCode"></param>
        /// <param name="groutingDay"></param>
        /// <param name="groutingBatchNo"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity UnBindGroutingLineBarCode(string groutingLineCode, string groutingDay, string groutingBatchNo, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            int result = -1;
            DataTable groutingTable=new DataTable();
            try
            {
                conn.Connect();
                //读取全线注浆记录,并判定是否有在产产品
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT
	                        GROUTINGDAILYID, -- AS 注浆ID,
                            GROUTINGDAILYDETAILID, -- AS 注浆日报明细ID
                            BARCODE, -- AS 产品条码,
                            BEGINNINGFLAG -- AS 在产标识
                        FROM
	                        TP_PM_GROUTINGDAILYDETAIL
                        WHERE
	                        VALUEFLAG = '1' 
	                        AND ACCOUNTID = {sUser.AccountID} 
	                        AND GROUTINGLINECODE = '{groutingLineCode}' 
	                        AND GROUTINGDATE = DATE '{groutingDay}' 
	                        AND GROUTINGBATCHNO = {groutingBatchNo}
                        ORDER BY
	                        GROUTINGMOULDCODE
                        ";
                    groutingTable = conn.GetSqlResultToDt(sqlStr);
                    if (groutingTable.Rows.Count > 0)
                    {
                        //判断是否有在产标识的记录
                        if(groutingTable.Select(" BEGINNINGFLAG = '1' ").Length==0)
                        {
                            sre.Status = Constant.ServiceResultStatus.Success;
                            sre.Message = "操作成功！";
                        }
                        else
                        {
                            sre.Status = Constant.ServiceResultStatus.ValidationFailed;
                            sre.Message = "成型线中有在产产品！";
                        }
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.ValidationFailed;
                        sre.Message = "成型线没找到注浆记录！";
                    }
                }
                //全线解绑条码处理 更新 注资日报表
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    //条码写入注浆表
                    sqlStr = $@"
                            UPDATE 
                                TP_PM_GROUTINGDAILYDETAIL
                            SET 
                                BARCODE = null
                            WHERE 
	                        ACCOUNTID = {sUser.AccountID} 
	                        AND GROUTINGLINECODE = '{groutingLineCode}' 
	                        AND GROUTINGDATE = DATE '{groutingDay}' 
	                        AND GROUTINGBATCHNO = {groutingBatchNo}
                        ";
                    result = conn.ExecuteNonQuery(sqlStr);
                    if (result == groutingTable.Rows.Count)
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.NoModifyData;
                        sre.Message = "条码更新失败！";
                    }
                }
                //解绑条码处理 删除 条码使用记录
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    string barCodes = "";
                    string groutingDailyDetailIds = "";
                    for (int i = 0; i < groutingTable.Rows.Count; i++)
                    {
                        if (i > 0) 
                        {
                            barCodes += ",";
                            groutingDailyDetailIds += ",";
                         };
                        barCodes += "'" + groutingTable.Rows[i]["BARCODE"].ToString() + "'";
                        groutingDailyDetailIds += groutingTable.Rows[i]["GROUTINGDAILYDETAILID"].ToString();
                    }
                    sqlStr = $@"
                            DELETE 
	                            TP_PM_USEDBARCODE 
                            WHERE 
	                            ACCOUNTID = {sUser.AccountID}
	                            AND BARCODE IN ({barCodes})
                                AND GROUTINGDAILYDETAILID IN ({groutingDailyDetailIds})
                        ";
                    result = conn.ExecuteNonQuery(sqlStr);

                    //有条码的解码，允许存在没绑码的记录
                    if (result > 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.NoModifyData;
                        sre.Message = "条码使用记录删除失败！";
                    }
                }
                //提交
                if (sre.Status == Constant.ServiceResultStatus.Success)
                    conn.Commit();
                else
                    conn.Rollback();
            }
            catch (Exception ex)
            {
                conn.Rollback();
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }

        /// <summary>
        /// 报损/取消报损处理
        /// </summary>
        /// <param name="groutingDailyDetailId"></param>
        /// <param name="scrapFlag"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity SetGroutingScrap(string groutingDailyDetailId, string scrapFlag, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            int result = -1;
            try
            {
                conn.Connect();

                int gl_id = Convert.ToInt32(conn.GetSqlResultToStr($"select g.groutinglineid from tp_pm_groutingdailydetail g where g.GROUTINGDAILYDETAILID = {groutingDailyDetailId}"));
                //未注浆/在产/已报损（不能重复操作）/撤销报损（不能重复操作） xuwei modify 2019-11-25
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT 
                            COUNT(GROUTINGDAILYDETAILID) 
                        FROM
                            TP_PM_GROUTINGDAILYDETAIL
                        WHERE 
                            ACCOUNTID = {sUser.AccountID}
                            AND (BEGINNINGFLAG = '1' OR SCRAPFlAG = '{scrapFlag}' OR GROUTINGFLAG = '0' ) 
                            AND GROUTINGDAILYDETAILID = {groutingDailyDetailId}
                        ";
                    result = Convert.ToInt32(conn.GetSqlResultToStr(sqlStr));
                    if (result == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.ValidationFailed;
                        sre.Message = "未注浆/在产/报损/的产品不能操作！";
                    }
                }
                //更新条码使用表 
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    //报损 BARCODESTATUS = 2 撤销报损 BARCODESTATUS = 1
                    int barCodeStatus = scrapFlag == "1" ? 2 : 1;
                    sqlStr = $@"
                            UPDATE 
	                            TP_PM_USEDBARCODE 
                            SET
                                BARCODESTATUS = {barCodeStatus}
                            WHERE 
	                            ACCOUNTID = {sUser.AccountID}
                                AND BARCODESTATUS <> -1
	                            AND GROUTINGDAILYDETAILID = {groutingDailyDetailId}
                        ";
                    result = conn.ExecuteNonQuery(sqlStr);
                    //result=1 是绑定条码的产品，result=0 是没绑条码的产品
                    if (result == 1 || result == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.NoModifyData;
                        sre.Message = "条码使用记录更新失败！";
                    }
                }
                //更新注浆表的SCRAPFlAG 损坯标记 SCRAPTYPE 损坏类型 0 开模损 null 正常
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    string scrapType = scrapFlag == "1" ? "'0'" : "null";
                    string ScrapTime = scrapFlag == "1" ? "sysdate" : "null";
                    sqlStr = $@"
                            UPDATE 
                                TP_PM_GROUTINGDAILYDETAIL
                            SET 
                                SCRAPFlAG = '{scrapFlag}',
                                SCRAPTYPE = {scrapType},
                                ScrapTime = {ScrapTime}
                            WHERE 
                                ACCOUNTID = {sUser.AccountID}
                                AND GROUTINGDAILYDETAILID = {groutingDailyDetailId}
                        ";
                    result = conn.ExecuteNonQuery(sqlStr);
                    if (result == 1)
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.NoModifyData;
                        sre.Message = "没有更新任何数据！";
                    }
                }
                //提交
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    conn.Commit();
                }
                else
                {
                    conn.Rollback();
                    return sre;
                }

                // 写入放行PLC
                if (scrapFlag == "1")
                {
                    Hashtable plcPara = new Hashtable();
                    plcPara.Add("finishflag", 1);
                    ServiceResultEntity sre_plc = PLCModuleLogic.PlcWrite_GL(3501, gl_id, plcPara, sUser.UserCode);
                }
            }
            catch (Exception ex)
            {
                conn.Rollback();
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }


        /// <summary>
        /// 按条码查询注浆日报详细信息
        /// </summary>
        /// <param name="barCode"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity GetGroutingDailyDetail(string barCode,SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            try
            {
                conn.Connect();
                //成型线注浆查询
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT
                            d.GROUTINGLINECODE, --AS 成型线编码,
                            d.GROUTINGDATE, --AS 注浆日期,
	                        d.GROUTINGDAILYID , --AS 注浆ID,
                            d.GROUTINGDAILYDETAILID, -- AS 注浆日报明细ID
                            d.GROUTINGBATCHNO ,-- AS 注浆批次,
	                        m.USERCODE ,-- AS 成型工号,
	                        m.MONITORCODE ,-- AS 成型班长,
	                        d.GROUTINGMOULDCODE,-- AS 模具编号,
	                        g.GOODSCODE,-- AS 产品编码,
	                        o.LOGONAME,-- AS 产品商标,
	                        d.GROUTINGFLAG,-- AS 注浆标识,
                            d.NOGROUTINGRREASON AS NOGROUTINGRREASONID, -- 未注浆原因ID
	                        y.DICTIONARYVALUE AS NOGROUTINGRREASON, -- AS 未注浆原因
	                        d.BARCODE,-- AS 绑定条码,
	                        d.SCRAPFLAG,-- AS 损坯标识,
                            d.BEGINNINGFLAG -- AS 在产标识
                        FROM
	                        TP_PM_GROUTINGDAILYDETAIL d	
	                        LEFT JOIN TP_MST_GOODS g ON g.GOODSID = d.GOODSID
	                        LEFT JOIN TP_MST_LOGO o ON o.LOGOID = d.LOGOID
	                        LEFT JOIN TP_PM_GROUTINGDAILY m ON m.GROUTINGDAILYID = d.GROUTINGDAILYID
	                        LEFT JOIN TP_MST_DATADICTIONARY y ON y.DICTIONARYID = d.NOGROUTINGRREASON
                        WHERE
	                        d.VALUEFLAG = '1' 
	                        AND d.ACCOUNTID = {sUser.AccountID} 
							AND d.BARCODE = '{barCode}'
                        ";
                    DataTable GroutingDailyDetail = conn.GetSqlResultToDt(sqlStr);
                    GroutingDailyDetail.TableName = "GroutingDailyDetail";
                    sre.Data.Tables.Add(GroutingDailyDetail);
                    if (GroutingDailyDetail.Rows.Count == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "没有查询结果！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                }
                //成型线信息查询 查询参数使用了sre.data中的GroutingDailyDetail表中的数据
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    string groutingLineCode = sre.Data.Tables["GroutingDailyDetail"].Rows[0]["GROUTINGLINECODE"].ToString();
                    sqlStr = $@"
                        SELECT
	                        l.GROUTINGLINECODE ,-- AS 成型线号,
	                        l.LASTGROUTINGDATE ,-- AS 已注浆日期,
	                        l.LASTGROUTINGBATCHNO ,-- AS 已注浆批次,
	                        u.USERCODE ,-- AS 成型工号,
	                        m.USERCODE AS MONITORUSERCODE,-- AS 成型班长,
	                        l.MOULDQUANTITY, -- AS 模具数量, 
	                        t.CANMANYTIMES -- AS 允许多次注浆
                        FROM
	                        TP_PC_GROUTINGLINE l
	                        LEFT JOIN TP_MST_USER u ON l.USERID = u.USERID
	                        LEFT JOIN TP_MST_USER m ON l.USERID = m.USERID
	                        LEFT JOIN TP_MST_GMOULDTYPE t ON l.GMOULDTYPEID = t.GMOULDTYPEID 
                        WHERE
	                        l.VALUEFLAG = '1' --有效标识
                            AND l.ACCOUNTID = {sUser.AccountID}
                            AND l.GROUTINGLINECODE = '{groutingLineCode}'
                        ";
                    DataTable groutingLine = conn.GetSqlResultToDt(sqlStr);
                    groutingLine.TableName = "GroutingLine";
                    sre.Data.Tables.Add(groutingLine);
                    if (groutingLine.Rows.Count == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "没有查询结果！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }


        /// <summary>
        /// 按条码查询成检交接信息 2020-06-26 xuwei
        /// </summary>
        /// <param name="barCode"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity GetPreProductCheck(string barCode, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            try
            {
                conn.Connect();
                //成型线注浆查询
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT
	                        i.GOODSLEVELTYPEID,
                            i.REWORKPROCEDUREID
                        FROM
	                        TP_PM_INPRODUCTION i
                        WHERE
	                        i.BARCODE = {barCode}
                            AND i.MODELTYPE = -4
                        ";
                    DataTable PreProductCheck = conn.GetSqlResultToDt(sqlStr);
                    PreProductCheck.TableName = "PreProductCheck";
                    sre.Data.Tables.Add(PreProductCheck);
                    if (PreProductCheck.Rows.Count == 0)
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "没有查询结果！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            //返回数据
            return sre;
        }



        /// <summary>
        /// 读取旧的防伪码 xuwei edit 2021-09-11 多读取一些产品信息
        /// </summary>
        /// <param name="barCode">产品条码</param>ram>
        /// 陈强 2021-08-9 新建
        /// <returns>int</returns>
        public static ServiceResultEntity GetSecurityCodeByBarcode(string barCode, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            try
            {
                conn.Connect();
                //读取防伪码
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    string sqlString = @"
                        SELECT
	                        GD.BARCODE,
	                        GD.SECURITYCODE,
	                        GD.GOODSCODE,
	                        GT.GOODSTYPECODE
                        FROM
	                        TP_PM_GROUTINGDAILYDETAIL GD
	                        LEFT JOIN TP_MST_GOODS G ON GD.GOODSID = G.GOODSID
	                        LEFT JOIN TP_MST_GOODSTYPE GT ON G.GOODSTYPEID = GT.GOODSTYPEID 
	                    WHERE
                            GD.BARCODE =:BARCODE 
	                        AND GD.VALUEFLAG =1
                    ";
                    OracleParameter[] paras = new OracleParameter[]{
                    new OracleParameter(":BARCODE",OracleDbType.Varchar2, barCode,ParameterDirection.Input),
                };

                    DataTable data = conn.GetSqlResultToDt(sqlString, paras);
                    data.TableName = "Data";
                    sre.Data.Tables.Add(data);

                    if (data != null && data.Rows.Count > 0 && data.Rows[0]["SecurityCode"].ToString() != "")
                    {
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "防伪码读取成功！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "没有查询结果！";
                    }
                }
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            return sre;
        }

        /// <summary>
        /// 绑定防伪码
        /// </summary>
        /// <param name="barcode">产品条码</param>ram>
        /// <param name="procedureID">工序ID</param>ram>
        /// <param name="securityCode">防伪码</param>
        /// 陈强 2021-08-9 新建
        /// <returns>int</returns>
        public static ServiceResultEntity UpdateSecurityCodeByBarcode(string barCode, string securityCode, string procedureID, SUserInfo sUser)
        {
            IDBTransaction oracleTrConn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            ServiceResultEntity sre = new ServiceResultEntity();
            int retnrnRows = 0;
            int retnrnRows2 = 0;
            string sqlString = null;
            bool b = true;//true 有防伪码  false 无防伪码
            try
            {
                oracleTrConn.Connect();              
                #region 查此件原来有没有防伪码
                sqlString = @"SELECT 
                                            SECURITYCODE 
                                     FROM  
                                            TP_PM_GROUTINGDAILYDETAIL
                                     WHERE
	                                        BARCODE =:BARCODE 
	                                        AND VALUEFLAG =1";
                OracleParameter[] paras = new OracleParameter[]{
                        new OracleParameter(":BARCODE",OracleDbType.Varchar2, barCode,ParameterDirection.Input)
                    };
                DataTable SecurityCode = oracleTrConn.GetSqlResultToDt(sqlString, paras);
                if (SecurityCode != null && SecurityCode.Rows.Count > 0 && SecurityCode.Rows[0]["SecurityCode"].ToString() != "")
                {
                    //有防伪码 —— 防伪码变更
                    b = true;
                }
                else {
                    //无防伪码 —— 防伪码绑定
                    b = false;
                }

                #region 检验输入的防伪码是否被使用过
                sqlString = @"SELECT
	                                1 
                                FROM
	                                TP_PM_GROUTINGDAILYDETAIL 
                                WHERE
	                                VALUEFLAG = 1 
	                                AND SECURITYCODE = :SECURITYCODE";
                paras = new OracleParameter[]{
                            new OracleParameter(":SECURITYCODE",OracleDbType.Varchar2, securityCode,ParameterDirection.Input),
                            };
                DataTable dt = oracleTrConn.GetSqlResultToDt(sqlString, paras);
                // 被使用过则不能被再次使用
                if (SecurityCode != null && SecurityCode.Rows.Count > 0 && SecurityCode.Rows[0]["SecurityCode"].ToString() != "")
                {
                    sre.Status = Constant.ServiceResultStatus.NoModifyData;
                    sre.Message = "防伪码被使用过！";
                }

                #endregion

                #region 写防伪码(变更和绑定都走这个)
                sqlString = @"UPDATE 
                                            TP_PM_GROUTINGDAILYDETAIL 
                                    SET 
                                            SECURITYCODE = :SECURITYCODE 
                                    WHERE
	                                        BARCODE =:BARCODE 
	                                        AND VALUEFLAG =1";
                paras = new OracleParameter[]{
                            new OracleParameter(":BARCODE",OracleDbType.Varchar2, barCode,ParameterDirection.Input),
                            new OracleParameter(":SECURITYCODE",OracleDbType.Varchar2, securityCode,ParameterDirection.Input),
                            };
                retnrnRows = oracleTrConn.ExecuteNonQuery(sqlString, paras);

                #endregion

                #endregion
                // 防伪码变更
                if (b)
                {
                    #region 记录变更日志 
                    // 成功
                    if (retnrnRows > 0)
                    {
                        sqlString = @"INSERT INTO TP_MST_SECURITYCODELOG 
                                    ( USERID,   BARCODE,  OLDSECURITYCODE,   NEWSECURITYCODE,   CREATETIME,  OPERATION,   REMARKS,  PROCEDUREID )
                            VALUES  (:USERID,  :BARCODE, :OLDSECURITYCODE,  :NEWSECURITYCODE,   SYSDATE,    :OPERATION,  :REMARKS, :PROCEDUREID )";
                        paras = new OracleParameter[]{
                            new OracleParameter(":USERID",OracleDbType.Int32, sUser.UserID,ParameterDirection.Input),
                            new OracleParameter(":BARCODE",OracleDbType.Varchar2, barCode,ParameterDirection.Input),
                            new OracleParameter(":OLDSECURITYCODE",OracleDbType.Varchar2, null,ParameterDirection.Input),
                            new OracleParameter(":NEWSECURITYCODE",OracleDbType.Varchar2, securityCode,ParameterDirection.Input),
                            new OracleParameter(":OPERATION",OracleDbType.Int32, 2,ParameterDirection.Input),
                            new OracleParameter(":REMARKS",OracleDbType.Varchar2," 【时间】 "+DateTime.Now.ToString() + " 【用户】 " + sUser.UserName+ " 【操作条码】 "+ barCode +" 【变更防伪码】 "+ SecurityCode.Rows [ 0 ][ "SecurityCode" ] + " 更改为 " + securityCode ,ParameterDirection.Input),
                            new OracleParameter(":PROCEDUREID",OracleDbType.Int32, Convert.ToInt32(procedureID) ,ParameterDirection.Input)
                            };
                        retnrnRows2 = oracleTrConn.ExecuteNonQuery(sqlString, paras);
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "防伪码变更成功！";
                    }
                    else
                    {
                        sre.Status = Constant.ServiceResultStatus.NoModifyData;
                        sre.Message = "防伪码变更失败！";
                    }
                }
                //防伪码绑定
                else {
                        #region 记录操作日志 
                        // 成功
                        if (retnrnRows > 0)
                        {
                            sqlString = @"INSERT INTO TP_MST_SECURITYCODELOG 
                                    ( USERID,   BARCODE,  OLDSECURITYCODE,   NEWSECURITYCODE,   CREATETIME,  OPERATION,   REMARKS,  PROCEDUREID )
                            VALUES  (:USERID,  :BARCODE, :OLDSECURITYCODE,  :NEWSECURITYCODE,   SYSDATE,    :OPERATION,  :REMARKS, :PROCEDUREID )";
                            paras = new OracleParameter[]{
                            new OracleParameter(":USERID",OracleDbType.Int32, sUser.UserID,ParameterDirection.Input),
                            new OracleParameter(":BARCODE",OracleDbType.Varchar2, barCode,ParameterDirection.Input),
                            new OracleParameter(":OLDSECURITYCODE",OracleDbType.Varchar2, null,ParameterDirection.Input),
                            new OracleParameter(":NEWSECURITYCODE",OracleDbType.Varchar2, securityCode,ParameterDirection.Input),
                            new OracleParameter(":OPERATION",OracleDbType.Int32, 1,ParameterDirection.Input),
                            new OracleParameter(":REMARKS",OracleDbType.Varchar2," 【时间】 "+DateTime.Now.ToString() + " 【用户】 " + sUser.UserName+ " 【操作条码】 "+ barCode +" 【绑定防伪码】 "+ securityCode ,ParameterDirection.Input),
                            new OracleParameter(":PROCEDUREID",OracleDbType.Int32, Convert.ToInt32(procedureID) ,ParameterDirection.Input),
                            };
                            retnrnRows2 = oracleTrConn.ExecuteNonQuery(sqlString, paras);
                            sre.Status = Constant.ServiceResultStatus.Success;
                            sre.Message = "防伪码绑定成功！";
                        }
                        #endregion
                        else
                        {
                            sre.Status = Constant.ServiceResultStatus.NoModifyData;
                            sre.Message = "防伪码绑定失败！";
                        }
                    }
                #endregion
                
                oracleTrConn.Commit();
            }
            catch (Exception ex)
            {
                oracleTrConn.Rollback();
                throw ex;
            }
            finally
            {
                // 释放资源
                if (oracleTrConn.ConnState == System.Data.ConnectionState.Open)
                {
                    oracleTrConn.Disconnect();
                }
            }
            return sre;
        }

        /// <summary>
        /// 校验防伪码
        /// </summary>
        /// <param name="barCode">产品条码</param>
        /// <param name="securityCode">防伪码</param>
        /// 陈强 2021-08-11 新建
        /// <returns>int</returns>
        public static ServiceResultEntity CheckSecurityCodeByBarcode(string barCode, string securityCode, SUserInfo sUser)
        {
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            ServiceResultEntity sre = new ServiceResultEntity();
            string sqlString = null;
            try
            {
                conn.Connect();

                #region 验证防伪码处理
                sqlString = @"  SELECT    
                                        1
                                FROM    
                                        TP_PM_GROUTINGDAILYDETAIL
                                WHERE
	                                    BARCODE = :BARCODE 
	                            AND     VALUEFLAG = 1
                                AND     SECURITYCODE = :SECURITYCODE";
                OracleParameter[] paras = new OracleParameter[]{
                        new OracleParameter(":BARCODE",OracleDbType.Varchar2, barCode,ParameterDirection.Input),
                        new OracleParameter(":SECURITYCODE",OracleDbType.Varchar2, securityCode,ParameterDirection.Input),
                    };
                DataTable dt = conn.GetSqlResultToDt(sqlString, paras);
               
                if (dt !=null && dt.Rows.Count>0 )
                {
                    sre.Status = Constant.ServiceResultStatus.Success;
                    sre.Message = "防伪码验证成功！";
                }
                else
                {
                    sre.Status = Constant.ServiceResultStatus.NoModifyData;
                    sre.Message = "防伪码验证失败！";
                }
                #endregion

            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            return sre;
        }

        /// <summary>
        /// 读取防伪码设置 xuwei add 2021-09-10
        /// </summary>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity GetSecurityCodeSetting(SUserInfo sUser)
        {
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            ServiceResultEntity sre = new ServiceResultEntity();
            string sqlString = null;
            try
            {
                conn.Connect();

                #region 读系统参数
                sqlString = @"
                    SELECT
	                    B.SETTINGVALUE AS BINDPROCEDUREID,
	                    C.SETTINGVALUE AS CHECKROCEDUREID,
	                    V.SETTINGVALUE AS GOODSTYPECODE
                    FROM
	                    TP_MST_SYSTEMSETTING V
	                    LEFT JOIN TP_MST_SYSTEMSETTING B ON B.SETTINGCODE = 'S_PM_030'
	                    LEFT JOIN TP_MST_SYSTEMSETTING C ON C.SETTINGCODE = 'S_PM_031'
                    WHERE
	                    V.SETTINGCODE = 'S_PM_032'
                ";
                DataTable dt = conn.GetSqlResultToDt(sqlString);
                dt.TableName = "SETTING";
                if (dt.Rows.Count > 0)
                {
                    sre.Data = new DataSet();
                    sre.Data.Tables.Add(dt);
                    sre.Status = Constant.ServiceResultStatus.Success;
                    sre.Message = "系统参数读取成功！";
                }
                else
                {
                    sre.Status = Constant.ServiceResultStatus.SystemError;
                    sre.Message = "系统参数不存在！";
                }

                #endregion
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            return sre;
        }



        /// <summary>
        /// pda端注浆登记验证工号的注浆权限
        /// </summary>
        /// <param name="groutingData">注浆信息</param>
        /// lsq 2021-08-25 新建
        /// <returns>int</returns>
        public static ServiceResultEntity CheckGroutingPower(string groutingData, SUserInfo sUser)
        {
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            ServiceResultEntity sre = new ServiceResultEntity();
            ServiceResultEntity sre1 = new ServiceResultEntity();
            string sqlString = null;
            try
            {
                conn.Connect();
                JObject jsonL = JObject.Parse(groutingData);

                #region pda端注浆登记验证工号的注浆权限
                sqlString = $@"  SELECT    
                                        1
                                FROM    
                                        TP_PC_GROUTINGLINE GL
                                INNER JOIN
                                        TP_PC_GROUTINGUSER GU
                                ON
                                        GL.GROUTINGLINEID = GU.GROUTINGLINEID
                                WHERE
	                                    GL.ACCOUNTID = {sUser.AccountID}
	                            AND     GU.USERID = {sUser.UserID}
	                            AND     GL.VALUEFLAG = 1
                                AND     GL.GROUTINGLINECODE =  '{jsonL["GROUTINGLINECODE"].ToString()}'
                    ";
                string str = conn.GetSqlResultToStr(sqlString);

                if (str == "1" )
                {
                    sre1 = SetGroutingLineDetail(groutingData, sUser);
                    sre.Status = sre1.Status;
                    sre.Message = sre1.Message;
                }
                else
                {
                    sre.Status = Constant.ServiceResultStatus.NoModifyData;
                    sre.Message = "无注浆权限！";
                }
                #endregion

            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            return sre;
        }

        /// <summary>
        /// 通用读取系统设置参数方法 xuwei add 2021-09-11
        /// </summary>
        /// <param name="SettingCode"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity GetSystemSetting(string SettingCode, SUserInfo sUser)
        {
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            string sqlString = null;
            try
            {
                conn.Connect();

                #region 读系统参数
                sqlString = @"
                    SELECT
	                    * 
                    FROM
	                    TP_MST_SYSTEMSETTING 
                    WHERE
	                    SETTINGCODE = :SETTINGCODE
                ";
                OracleParameter[] paras = new OracleParameter[]{
                        new OracleParameter(":SETTINGCODE",OracleDbType.Varchar2, SettingCode,ParameterDirection.Input),
                };
                DataTable dt = conn.GetSqlResultToDt(sqlString, paras);
                dt.TableName = "SETTING";
                if (dt.Rows.Count > 0)
                {
                    sre.Data.Tables.Add(dt);
                    sre.Result = dt.Rows[0]["SETTINGVALUE"].ToString();
                    sre.Status = Constant.ServiceResultStatus.Success;
                    sre.Message = "系统参数读取成功！";
                }
                else
                {
                    sre.Status = Constant.ServiceResultStatus.SystemError;
                    sre.Message = "系统参数不存在！";
                }

                #endregion
            }
            catch (Exception ex)
            {
                throw ex;
            }
            finally
            {
                conn.Disconnect();
            }
            return sre;
        }

        #endregion
    }
}