/*******************************************************************************
 * 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 Dongke.IBOSS.PRD.Service.PMModuleService;
using System.Collections;
using System.Linq;

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 = :usercode
                        ";
                    OracleParameter[] Paras = new OracleParameter[] {
                            new OracleParameter(":groutingLineCode",OracleDbType.Varchar2, groutingLineCode,ParameterDirection.Input),
                            new OracleParameter(":usercode",OracleDbType.Varchar2, sUser.UserCode,ParameterDirection.Input),
                        };
                    DataTable purview = conn.GetSqlResultToDt(sqlStr, Paras);
                    //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 = :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
                        ";
                        OracleParameter[] par = new OracleParameter[] {
                            new OracleParameter(":groutingLineCode",OracleDbType.Varchar2, groutingLineCode,ParameterDirection.Input),
                            new OracleParameter(":ACCOUNTID",OracleDbType.Varchar2, sUser.AccountID,ParameterDirection.Input),
                        };
                        DataTable groutingLine = conn.GetSqlResultToDt(sqlStrNext, par);
                        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)
                {
                    //if (!string.IsNullOrWhiteSpace(groutingLineCode) && groutingLineCode.Contains("'"))
                    //{
                    //    sre.Status = Constant.ServiceResultStatus.Other;
                    //    sre.OtherStatus = -1;
                    //    sre.Message = "成型线输入错误，包含其他字符，请核对！";
                    //    return sre;
                    //}
                    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 产品商标
                            CASE WHEN d.LOGOID IS NULL THEN o.LOGONAME
							ELSE  (SELECT LOGONAME FROM TP_MST_LOGO WHERE LOGOID=d.LOGOID ) END AS 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)
                {
					//if (!string.IsNullOrWhiteSpace(groutingLineCode) && groutingLineCode.Contains("'"))
					//{
     //                   sre.Status = Constant.ServiceResultStatus.Other;
     //                   sre.OtherStatus = -1;
     //                   sre.Message = "成型线输入错误，包含其他字符，请核对！";
     //                   return sre;
     //               }
                    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();

                #region 多条成型线绑定注浆（成型线组） 20260313 
                int spm33value = PMModuleLogic.getSystemSet(conn, "S_PM_033", sUser);
                // 创建列表存储 【主线 + 辅线】 的所有独立 JSON
                List<string> allGroutingJsons = new List<string>();
                // 先把【原始主线JSON】加入列表（结构完全不变）
                allGroutingJsons.Add(groutingData);
                if (spm33value == 1)
				{ 
                    // 解析原始主线 JSON
                    JObject mainJson = JObject.Parse(groutingData);
                    string mainLineCode = mainJson["GROUTINGLINECODE"].ToString();
                    JArray mainDetail = (JArray)mainJson["GROUTINGLINEDETAIL"];
                      
                    // 根据主线编码 → 查询数据库 → 拿到 2 条辅成型线编码
                    DataTable slaveLines = conn.GetSqlResultToDt($@"
                        SELECT GroutingLineCode ,GroutingLineID
                        FROM TP_PC_GroutingLine 
                        WHERE H_LINECODE = '{mainLineCode}' 
                          AND ValueFlag = 1 AND GroutingLineCode <> H_LINECODE
                    ");

                    // 给每条辅线生成【结构完全一样】的独立 JSON
                    foreach (DataRow row in slaveLines.Rows)
                    {
                        // 查询辅成型线模具明细（校验用）
                        DataTable hlinedetaildt = conn.GetSqlResultToDt($@"
                                    SELECT * FROM TP_PC_GROUTINGLINEDETAIL 
                                    WHERE VALUEFLAG = 1 AND GMouldStatus = '1' AND GROUTINGLINEID = {row["GROUTINGLINEID"]}
                                ");

                        // 模具个数校验（和主线明细数量对比）
                        if (hlinedetaildt == null || hlinedetaildt.Rows.Count == 0)
                        {
                            sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                            sre.Message = $"注浆失败：辅注浆成型线【{row["GroutingLineCode"]}】无正常模具";  
                        }

                        // ldetaildt 是主线的正常模具数量，你原来的逻辑
                        if (hlinedetaildt.Rows.Count != mainDetail.Count)
                        {
                            sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                            sre.Message = $"注浆失败，请联系管理员核实【辅注浆成型线正常模具个数】是否准确-【{row["GroutingLineCode"]}】"; 
                        }

                        string slaveLineCode = row["GroutingLineCode"].ToString();

                        // 克隆主线 JSON（深度克隆，结构100%一致）
                        JObject slaveJson = JObject.Parse(mainJson.ToString());

                        // 只改 成型线编码
                        slaveJson["GROUTINGLINECODE"] = slaveLineCode;

                        // 模具编码自动替换：C05A02-001 → 辅线编码-001
                        JArray slaveDetail = (JArray)slaveJson["GROUTINGLINEDETAIL"];
                        //查询辅线模具编码是否与主线一致   
                        foreach (JObject item in slaveDetail)
                        {
                            string mouldCode = item["GROUTINGMOULDCODE"].ToString();
                            string suffix = mouldCode.Trim().Split('-').Last();
                            DataRow[] drows = hlinedetaildt.Select("GROUTINGMOULDCODE='" + slaveLineCode + "-" + suffix + "'");
                            if (drows == null)
                            {
                                sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                                sre.Message = $"注浆失败：辅线{slaveLineCode}模具未匹配主成型线模具位置"; 
                            } 
                            item["MAINGROUTINGFLAG"] = mouldCode;          // 主线模具号
                            item["MAINGROUTINGDAILYDETAILID"] = 0;             // 默认为0
                            item["GROUTINGMOULDCODE"] = $"{slaveLineCode}-{suffix}";
                        }

                        // 加入列表 → 得到独立的、可直接使用的辅线 JSON
                        allGroutingJsons.Add(slaveJson.ToString());
                    }
                }
				#endregion
				//foreach (string allGroutingJson in allGroutingJsons)
				for (int z = 0; z < allGroutingJsons.Count; z++) 
				{
                    string allGroutingJson = allGroutingJsons[z];
                    JObject jsonL = JObject.Parse(allGroutingJson);

                    //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 = "操作成功！";
                        }
                    }
                    */



                    //-----------------------------------------------------------------------
                    // 校验是否需要半成品卡控及卡控数量是否允许注浆操作 add by qq 20251216
                    #region 校验是否需要半成品卡控及卡控数量是否允许注浆操作
                    int systemSetvalue = PMModuleLogic.getSystemSet(conn, "S_PC_003", sUser);

                    #region 无论是否需要校验，都需要此表，注浆成功后需要反写计划表中的实际注浆量
                    string groutingMouldCodes = "";
                    JArray detailsarray = JArray.Parse(jsonL["GROUTINGLINEDETAIL"].ToString());
                    for (int i= 0;  i < detailsarray.Count; i++)
                    {
					    if (detailsarray[i]["GROUTINGFLAG"].ToString() == "1")
					    {
                            groutingMouldCodes += "'" + detailsarray[i]["GROUTINGMOULDCODE"].ToString() + "',";
                        }
                    }
                    string groutingdailyDetailsql = $@"SELECT G.GOODSCODE, O.LOGOID , COUNT(D.GROUTINGLINEDETAILID)*{jsonL["GROUTINGTIMES"]} COUNT ,'' MAT20,0 PRODPLANID
                                    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.ACCOUNTID = { sUser.AccountID}
                                    AND D.VALUEFLAG = '1' 
                                    AND D.GMOULDSTATUS = 1 
                                    AND L.GROUTINGLINECODE = '{jsonL["GROUTINGLINECODE"]}'
                                    AND D.GROUTINGMOULDCODE IN ({ groutingMouldCodes.Substring(0,groutingMouldCodes.Length -1) })
                                    AND G.SCRAPSUMFLAG = 1
                                    GROUP BY G.GOODSCODE,O.LOGOID ";

                    DataTable resultTable = conn.GetSqlResultToDt(groutingdailyDetailsql); 
                    #endregion

                    //S_PC_003为1时，需要校验当月该半成品物料的计划数量
                    if (systemSetvalue == 1)
                    {
                        for (int i = 0; i < resultTable.Rows.Count; i++)
                        {
                            //查询对应半成品物料(根据注浆的产品及商标)
                            string mat20 = PMModuleLogic.getmaterialcodeMat20(conn, resultTable.Rows[i]["GOODSCODE"].ToString(), Convert.ToInt32(resultTable.Rows[i]["LOGOID"]));

                            if (!string.IsNullOrWhiteSpace(mat20))
                            {
                                resultTable.Rows[i]["MAT20"] = mat20;
                                //查询半成品物料当月对应的计划数量
                                DataTable planTabel = PMModuleLogic.getPlanDetail(conn, 1, mat20, Convert.ToDateTime(jsonL["GROUTINGDATE"].ToString()));

                                if (planTabel != null && planTabel.Rows.Count > 0)
                                {
                                    resultTable.Rows[i]["PRODPLANID"] = Convert.ToInt32(planTabel.Rows[0]["PRODPLANID"]);
                                    //有计划，计划数量
                                    decimal planCount = Convert.ToDecimal(planTabel.Rows[0]["PLANCOUNT"]);
                                    //已完成数量
                                    decimal completedCount = 0;
                                    if (!string.IsNullOrWhiteSpace(planTabel.Rows[0]["COMPLETEDCOUNT"].ToString()))
                                    {
                                        completedCount = Convert.ToDecimal(planTabel.Rows[0]["COMPLETEDCOUNT"]);
                                    }
                                    if (Convert.ToDecimal(resultTable.Rows[i]["Count"]) > planCount - completedCount)
                                    {
                                        sre.Status = Constant.ServiceResultStatus.NoSearchResults; 
                                        sre.Message = "无法注浆：此次注浆超过产销卡控计划注浆数量，请核实。"; 
                                    }
                                }
							    else
							    {
                                    //无计划，无法注浆
                                    sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                                    sre.Message = "无法注浆：该物料无产销计划，请核实。";
                                }
                            }
                        }
                    }

                    #region 创建表存储每个新建的注浆明细ID
                    DataTable gddIDTable = new DataTable();
                    gddIDTable.Columns.Add("GOODSCODE", typeof(string));
                    gddIDTable.Columns.Add("LOGOID", typeof(int));
                    gddIDTable.Columns.Add("GROUTINGDAILYDETAILID", typeof(int));
                    gddIDTable.Columns.Add("GROUTINGFLAG", typeof(int));
                    #endregion

                    #endregion
                    //-----------------------------------------------------------------------


                    //获取是否有班次 设置 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)
                        {
                            sre.Status = Constant.ServiceResultStatus.SystemError;
                            sre.Message = "自动配置班次失败！";
                        }
                    }
                    //插入 注浆记录
                    if (sre.Status == Constant.ServiceResultStatus.Success)
                    {
                        try
                        {
                            sqlStr = "BEGIN";
                            string proSql = "";

                            //按注浆次数循环 保存注浆记录
                            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";
                                 
                                    //注浆明细ID
                                    int seqGroutingDailyDetailID = Convert.ToInt32( conn.GetSqlResultToStr(@"SELECT SEQ_PM_GroutingDailyD_ID.Nextval FROM DUAL"));

                                    //插入注浆记录明细
                                    sqlStr += $@"
                                    INSERT INTO TP_PM_GROUTINGDAILYDETAIL (
	                                    GROUTINGDAILYID,GROUTINGDAILYDETAILID,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
                                        -- 20220308 add 记录光瓷重量
                                        ,LUSTERWAREWEIGHT
                                        -- 20220308 add 记录光瓷重量 end
                                        -- 20220325 by feiy add 试验线
                                        ,TESTFLAG
                                        -- 20220325 by feiy add 试验线 end
                                        -- 20220812 by LSQ add 模具试验标识
                                        ,TESTMOULDFLAG
                                        -- 20220812 by LSQ add 模具试验标识 end
                                    ) SELECT
                                        {groutingDailyId},--GROUTINGDAILYID
                                        {seqGroutingDailyDetailID},--GROUTINGDAILYDETAILID
                                        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
                                        -- 20220308 add 记录光瓷重量
                                        ,NVL(g.LUSTERWAREWEIGHT,0)
                                        -- 20220308 add 记录光瓷重量 end
                                        -- 20220325 by feiy add 试验线
                                        ,l.TESTFLAG
                                        -- 20220325 by feiy add 试验线 end
                                        -- 20220812 by LSQ add 模具试验标识
                                        ,M.TESTMOULDFLAG
                                        -- 20220812 by LSQ add 模具试验标识 end
                                    FROM
	                                    TP_PC_GROUTINGLINEDETAIL d
	                                    LEFT JOIN TP_PC_GROUTINGLINE l ON l.GROUTINGLINEID = d.GROUTINGLINEID
                                        LEFT JOIN TP_PC_MOULD M  ON d.MOULDID = M.MOULDID
	                                    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()}'
                                    //;";

                                    #region 有主线标识并且没有数据的 为绑定注浆里的主注浆线 20260313
                                    // 生成的 主线明细ID
                                    int mainGroutingDailyDetailID = Convert.ToInt32(seqGroutingDailyDetailID);
                                    //绑定注浆
									if (allGroutingJsons.Count > 1)
									{
                                        //主线的明细,MAINGROUTINGFLAG值为空
                                        if (!allGroutingJson.Contains("MAINGROUTINGFLAG"))
										{
                                            // 找到所有辅线，更新主线ID 
                                            for (int m = 1; m < allGroutingJsons.Count; m++) // 跳过主线，从第2条开始（辅线）
                                            {
                                                // 取出来
                                                string jsonStr = allGroutingJsons[m];
                                                JObject jObj = JObject.Parse(jsonStr);

                                                JArray detail = (JArray)jObj["GROUTINGLINEDETAIL"];

                                                // 查找匹配项
                                                JObject matchItem = detail.FirstOrDefault(d =>
                                                    d["MAINGROUTINGFLAG"]?.ToString() == jsonM[j]["GROUTINGMOULDCODE"]?.ToString()
                                                ) as JObject;

                                                if (matchItem != null)
                                                {
                                                    // 修改  如果找到，直接更新主线ID
                                                    matchItem["MAINGROUTINGDAILYDETAILID"] = mainGroutingDailyDetailID;
                                                }

                                                // 👇 关键：把改完的 JSON 重新放回列表里
                                                allGroutingJsons[m] = jObj.ToString();
                                            }
                                        }
										else
										{
                                            //辅成型线，更新MAINGROUTINGDAILYDETAILID 为主成型线注浆明细ID
                                            proSql += $@"UPDATE TP_PM_GroutingDailyDetail SET MAINGROUTINGDAILYDETAILID = {Convert.ToInt32(jsonM[j]["MAINGROUTINGDAILYDETAILID"])} WHERE GROUTINGDAILYDETAILID = {seqGroutingDailyDetailID};";
                                            //OracleParameter[] proParas = new OracleParameter[]
                                            //{
                                            //    new OracleParameter(":MAINGROUTINGDAILYDETAILID", OracleDbType.Int32, Convert.ToInt32(jsonM[j]["MAINGROUTINGDAILYDETAILID"]), ParameterDirection.Input),
                                            //    new OracleParameter(":GROUTINGDAILYDETAILID", OracleDbType.Int32, seqGroutingDailyDetailID, ParameterDirection.Input),
                                            //};
                                            //conn.ExecuteNonQuery(proSql, proParas);
                                        } 
                                    }   
                                    #endregion

                                    #region 插入注浆ID表
                                    groutingdailyDetailsql = $@"SELECT G.GOODSCODE, O.LOGOID 
                                     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.ACCOUNTID = { sUser.AccountID}
                                        AND D.VALUEFLAG = '1' 
                                        AND D.GMOULDSTATUS = 1 
                                        AND L.GROUTINGLINECODE = '{jsonL["GROUTINGLINECODE"]}'
                                        AND D.GROUTINGMOULDCODE = '{jsonM[j]["GROUTINGMOULDCODE"]}'
                                       GROUP BY G.GOODSCODE,O.LOGOID ";

                                    DataTable goodsTable = conn.GetSqlResultToDt(groutingdailyDetailsql);
								    if (goodsTable != null && goodsTable.Rows.Count > 0)
								    {
                                        DataRow newRow = gddIDTable.NewRow();
                                        newRow["GOODSCODE"] = goodsTable.Rows[0]["GOODSCODE"].ToString();
                                        newRow["LOGOID"] = Convert.ToInt32(goodsTable.Rows[0]["LOGOID"]);
                                        newRow["GROUTINGDAILYDETAILID"] = Convert.ToInt32(seqGroutingDailyDetailID);
                                        newRow["GROUTINGFLAG"] = Convert.ToInt32(jsonM[j]["GROUTINGFLAG"].ToString());
                                        gddIDTable.Rows.Add(newRow);
                                    } 
                                    #endregion

                                }
                                sre.Result = groutingDailyId;
                            }
                            sqlStr += "END;";
                            result = conn.ExecuteNonQuery(sqlStr);
							if (!string.IsNullOrWhiteSpace(proSql))
							{
                                result += conn.ExecuteNonQuery("BEGIN " +proSql+ " END;");
                            } 
                            sre.Status = Constant.ServiceResultStatus.Success;
                            sre.Message = "操作成功！";

                            //2022年8月24日09:32:29 注浆次数
                            sqlStr = "BEGIN";
                            for (int i = 0; i < Convert.ToInt32(jsonL["GROUTINGTIMES"].ToString()); i++)
                            {
                                JArray jsonM = JArray.Parse(jsonL["GROUTINGLINEDETAIL"].ToString());
                                for (int j = 0; j < jsonM.Count; j++)
                                {
                                    //更新注浆次数
                                    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()}'
                                    ;";
                                }
                            }
                            sqlStr += "END;";
                      
                            result = conn.ExecuteNonQuery(sqlStr);
                            sre.Status = Constant.ServiceResultStatus.Success;
                            sre.Message = "操作成功！";
                            //2022年8月24日09:32:48 结束
                        }
                        catch (Exception ex)
                        {
                            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 = "成型线最后注浆日期和注浆批次更新失败！";
                        }
                    }

                    #region 注浆之后反写半成品卡控计划物料计划数量

                    for (int i = 0; i < resultTable.Rows.Count; i++)
                    {
                        int proPlanID = 0;
                        //S_PC_003为0时，需要查找每个产品对应的当月该半成品物料的计划ID
                        //为1时，校验时已经查询过，无须再查
                        if (systemSetvalue == 0)
                        {
                            //查询对应半成品物料(根据注浆的产品及商标)
                            string mat20 = PMModuleLogic.getmaterialcodeMat20(conn, resultTable.Rows[i]["GOODSCODE"].ToString(), Convert.ToInt32(resultTable.Rows[i]["LOGOID"]));

                            if (!string.IsNullOrWhiteSpace(mat20))
                            {
                                resultTable.Rows[i]["MAT20"] = mat20;
                                //查询半成品物料当月对应的计划数量
                                DataTable planTabel = PMModuleLogic.getPlanDetail(conn, 1, mat20, Convert.ToDateTime(jsonL["GROUTINGDATE"].ToString()));

                                if (planTabel != null && planTabel.Rows.Count > 0)
                                {
                                    //有计划,计划ID
                                    proPlanID = Convert.ToInt32(planTabel.Rows[0]["PRODPLANID"]);
                                }
                            }
                        }
                        else
                        {
                            if (!string.IsNullOrWhiteSpace(resultTable.Rows[i]["PRODPLANID"].ToString()))
                            {
                                proPlanID = Convert.ToInt32(resultTable.Rows[i]["PRODPLANID"]);
                            }
                        }

					    if (proPlanID > 0)
					    { 
                            string proSql = "UPDATE TP_SEMIFINISHED_PRODPLAN SET COMPLETEDCOUNT = COMPLETEDCOUNT + :PLANCOUNT WHERE PRODPLANID = :PRODPLANID AND MATERIALCODE = :MAT20";
                            OracleParameter[] proParas = new OracleParameter[]
                            {
                                new OracleParameter(":PLANCOUNT", OracleDbType.Int32, Convert.ToInt32(resultTable.Rows[i]["Count"]), ParameterDirection.Input),
                                new OracleParameter(":PRODPLANID", OracleDbType.Int32, proPlanID, ParameterDirection.Input),
                                new OracleParameter(":MAT20", OracleDbType.Varchar2, resultTable.Rows[i]["MAT20"].ToString(), ParameterDirection.Input),
                            };
                            int executeResult = conn.ExecuteNonQuery(proSql, proParas);

                            //查找注浆明细中该产品商标都有哪些，插入关联表
                            DataRow[] groutingDailyDetailRows = gddIDTable.Select("GOODSCODE = '" + resultTable.Rows[i]["GOODSCODE"].ToString()
                                + "' and LOGOID = " + resultTable.Rows[i]["LOGOID"].ToString() + " and GROUTINGFLAG = 1");
                            foreach (DataRow dailydetailDataRow in groutingDailyDetailRows)
                            {
                                proSql = "INSERT INTO TP_SEMIFINISHED_PRODPLANBAR (PRODPLANID,GROUTINGDAILYDETAILID,ACCOUNTID,CREATEUSERID) VALUES(:PRODPLANID,:GROUTINGDAILYDETAILID,:ACCOUNTID,:CREATEUSERID)";
                                proParas = new OracleParameter[]
                                {
                                    new OracleParameter(":PRODPLANID", OracleDbType.Int32, proPlanID, ParameterDirection.Input),
                                    new OracleParameter(":GROUTINGDAILYDETAILID", OracleDbType.Int32, Convert.ToInt32( dailydetailDataRow["GROUTINGDAILYDETAILID"]), ParameterDirection.Input),
                                    new OracleParameter(":ACCOUNTID", OracleDbType.Int32, sUser.AccountID, ParameterDirection.Input),
                                    new OracleParameter(":CREATEUSERID", OracleDbType.Int32, sUser.UserID, ParameterDirection.Input),
                                };
                                executeResult = conn.ExecuteNonQuery(proSql, proParas);
                            }
                        }
                    }
                        #endregion
                }
                //提交
                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 IN ( 
                                  SELECT GroutingLineDetailID
                                     FROM tp_pm_groutingdailydetail
                                     WHERE GROUTINGDAILYDETAILID = :GROUTINGDAILYDETAILID
                                     UNION
                                     SELECT GroutingLineDetailID
                                     FROM tp_pm_groutingdailydetail
                                     WHERE MAINGROUTINGDAILYDETAILID = :GROUTINGDAILYDETAILID ) ;
                                UPDATE  TP_PM_GROUTINGDAILYDETAIL
                                SET  GROUTINGCOUNT = GROUTINGCOUNT + :GROUTINGCOUNT
                                WHERE  (GROUTINGDAILYDETAILID = :GROUTINGDAILYDETAILID
                                     OR MAINGROUTINGDAILYDETAILID = :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 = "操作成功！";

                        for (int i = 0; i < json.Count; i++)
                        {
                            object date = CMNModuleLogic.GetAccountDate(conn, sUser);
                            DateTime groutingDate = Convert.ToDateTime(date).Date;

                            #region 编辑时，取消注浆对应减去计划中实际注浆数及关联数据，修改为注浆对应判断是否允许注浆，允许时对应计划增加实际注浆数 20251216
                            //读取原注浆记录进行比对，原来 注浆标识 为1 现在 注浆标识 为0 要-1  反之加1
                            dt = conn.GetSqlResultToDt($@"
                                SELECT  
                                    GDD.GROUTINGDAILYDETAILID,
                                    GDD.GROUTINGLINEDETAILID,
                                    GDD.GOODSCODE,
                                    GDD.LOGOID,
                                    GDD.GROUTINGDATE,
                                    GDD.GROUTINGFLAG
                                FROM
                                    TP_PM_GROUTINGDAILYDETAIL GDD
                                    LEFT JOIN TP_MST_GOODS G ON G.GOODSID = GDD.GOODSID 
                                WHERE  G.SCRAPSUMFLAG = 1 AND
                                    GDD.GROUTINGDAILYDETAILID = {json[i]["GROUTINGDAILYDETAILID"].ToString()}
                            ");
                              
                            if (json[i]["GROUTINGFLAG"].ToString() != dt.Rows[0]["GROUTINGFLAG"].ToString())
                            {
                                if (json[i]["GROUTINGFLAG"].ToString() == "0")
                                {
                                    //取消注浆
                                    //查询对应半成品物料(根据注浆的产品及商标)
                                    string mat20 = PMModuleLogic.getmaterialcodeMat20(conn, dt.Rows[0]["GOODSCODE"].ToString(), Convert.ToInt32(dt.Rows[0]["LOGOID"]));
                                    int proPlanID = 0;
                                    if (!string.IsNullOrWhiteSpace(mat20))
                                    {
                                        //查询半成品物料当月对应的计划数量
                                        DataTable planTabel = PMModuleLogic.getPlanDetail(conn, 1, mat20, groutingDate);

                                        if (planTabel != null && planTabel.Rows.Count > 0)
                                        {
                                            proPlanID = Convert.ToInt32(planTabel.Rows[0]["PRODPLANID"]);
                                        }
                                    }
                                    if (proPlanID > 0)
                                    {
                                        string proSql = "DELETE FROM  TP_SEMIFINISHED_PRODPLANBAR WHERE PRODPLANID = :PRODPLANID and GROUTINGDAILYDETAILID = :GROUTINGDAILYDETAILID";
                                        OracleParameter[] proParas = new OracleParameter[]
                                        {
                                            new OracleParameter(":PRODPLANID", OracleDbType.Int32, proPlanID, ParameterDirection.Input),
                                            new OracleParameter(":GROUTINGDAILYDETAILID", OracleDbType.Int32, Convert.ToInt32( dt.Rows[0]["GROUTINGDAILYDETAILID"]), ParameterDirection.Input),
                                            new OracleParameter(":ACCOUNTID", OracleDbType.Int32, sUser.AccountID, ParameterDirection.Input),
                                            new OracleParameter(":CREATEUSERID", OracleDbType.Int32, sUser.UserID, ParameterDirection.Input),
                                        };
                                        int executeResult = conn.ExecuteNonQuery(proSql, proParas);

                                        //确保之前的注浆数据绑定在该月计划单上
                                        if (executeResult > 0)
                                        {
                                            proSql = "UPDATE TP_SEMIFINISHED_PRODPLAN SET COMPLETEDCOUNT = COMPLETEDCOUNT - :PLANCOUNT WHERE PRODPLANID = :PRODPLANID ";
                                            proParas = new OracleParameter[]
                                            {
                                                new OracleParameter(":PLANCOUNT", OracleDbType.Int32, 1, ParameterDirection.Input),
                                                new OracleParameter(":PRODPLANID", OracleDbType.Int32, proPlanID, ParameterDirection.Input),
                                            };
                                            executeResult = conn.ExecuteNonQuery(proSql, proParas);
                                        }
                                    }
                                     
                                }
                                else
                                {
                                    //注浆
                                    int systemSetvalue = PMModuleLogic.getSystemSet(conn, "S_PC_003", sUser);
                                    int proPlanID = 0;
                                    //查询对应半成品物料(根据注浆的产品及商标)
                                    string mat20 = PMModuleLogic.getmaterialcodeMat20(conn, dt.Rows[0]["GOODSCODE"].ToString(), Convert.ToInt32(dt.Rows[0]["LOGOID"]));

                                    if (!string.IsNullOrWhiteSpace(mat20))
                                    {
                                        //查询半成品物料当月对应的计划数量
                                        DataTable planTabel = PMModuleLogic.getPlanDetail(conn, 1, mat20, groutingDate);

                                        if (planTabel != null && planTabel.Rows.Count > 0)
                                        {
                                            proPlanID = Convert.ToInt32(planTabel.Rows[0]["PRODPLANID"]);
                                            //有计划，计划数量
                                            decimal planCount = Convert.ToDecimal(planTabel.Rows[0]["PLANCOUNT"]);
                                            //已完成数量
                                            decimal completedCount = 0;
                                            if (!string.IsNullOrWhiteSpace(planTabel.Rows[0]["COMPLETEDCOUNT"].ToString()))
                                            {
                                                completedCount = Convert.ToDecimal(planTabel.Rows[0]["COMPLETEDCOUNT"]);
                                            }
                                            if (systemSetvalue == 1 && 1 > planCount - completedCount)
                                            {
                                                sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                                                sre.Message = "无法注浆：此次编辑注浆超过产销卡控计划注浆数量，请核实。";
                                                break;
                                            }
                                        }
                                        else
                                        {
                                            if (systemSetvalue == 1)
                                            {
                                                //无计划，无法注浆
                                                sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                                                sre.Message = "无法注浆：该物料无产销计划，请核实。";
                                            }
                                        }
                                    }

                                    if (proPlanID > 0)
                                    {
                                        string proSql = "UPDATE TP_SEMIFINISHED_PRODPLAN SET COMPLETEDCOUNT = COMPLETEDCOUNT + :PLANCOUNT WHERE PRODPLANID = :PRODPLANID ";
                                        OracleParameter[] proParas = new OracleParameter[]
                                        {
                                        new OracleParameter(":PLANCOUNT", OracleDbType.Int32, 1, ParameterDirection.Input),
                                        new OracleParameter(":PRODPLANID", OracleDbType.Int32, proPlanID, ParameterDirection.Input),
                                        };
                                        int executeResult = conn.ExecuteNonQuery(proSql, proParas);

                                        proSql = "INSERT INTO TP_SEMIFINISHED_PRODPLANBAR (PRODPLANID,GROUTINGDAILYDETAILID,ACCOUNTID,CREATEUSERID) VALUES(:PRODPLANID,:GROUTINGDAILYDETAILID,:ACCOUNTID,:CREATEUSERID)";
                                        proParas = new OracleParameter[]
                                        {
                                            new OracleParameter(":PRODPLANID", OracleDbType.Int32, proPlanID, ParameterDirection.Input),
                                            new OracleParameter(":GROUTINGDAILYDETAILID", OracleDbType.Int32, Convert.ToInt32( dt.Rows[0]["GROUTINGDAILYDETAILID"]), ParameterDirection.Input),
                                            new OracleParameter(":ACCOUNTID", OracleDbType.Int32, sUser.AccountID, ParameterDirection.Input),
                                            new OracleParameter(":CREATEUSERID", OracleDbType.Int32, sUser.UserID, ParameterDirection.Input),
                                        };
                                        executeResult = conn.ExecuteNonQuery(proSql, proParas);
                                    }

                                }

                            }
                            #endregion
                        }
                    }
                    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 OR  MAINGROUTINGDAILYDETAILID = :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();
                //防伪码位数校验
                if (!string.IsNullOrEmpty(securityCode) ) {
                    if (securityCode.Length != 12)
                    {
                        sre.Status = Constant.ServiceResultStatus.NoModifyData;
                        sre.Message = "防伪码位数不对！";
                        return sre;
                    }
                };
                #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 (dt != null && dt.Rows.Count > 0)
                {
                    sre.Status = Constant.ServiceResultStatus.NoModifyData;
                    sre.Message = "防伪码被使用过！";
                    return sre;
                }

                #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
	                T1.BINDPROCEDUREID,
	                T1.CHECKROCEDUREID,
	                T1.GOODSTYPECODE,
	                T2.GOODSLISTBIND， 
	                T3.GOODSLISTCHECK
                FROM
	                (
	                SELECT
		                B.SETTINGVALUE AS BINDPROCEDUREID,
		                C.SETTINGVALUE AS CHECKROCEDUREID,
		                V.SETTINGVALUE AS GOODSTYPECODE,
		                1 AS WJ 
	                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' 
	                ) T1
	                INNER JOIN (
	                SELECT
		                1 AS WJ,
		                SECURITYCODEBINDFLAG,
		                LISTAGG ( TO_CHAR(GOODSCODE), ',' ) WITHIN GROUP ( ORDER BY GOODSID ) AS GOODSLISTBIND 
	                FROM
		                TP_MST_GOODS 
	                WHERE
		                SECURITYCODEBINDFLAG = 1 
	                GROUP BY
	                SECURITYCODEBINDFLAG 
	                ) T2 ON T1.WJ = T2.WJ
	                LEFT JOIN (
	                SELECT
		                1 AS WJ,
		                SECURITYCODECHECKFLAG,
		                LISTAGG ( TO_CHAR(GOODSCODE), ',' ) WITHIN GROUP ( ORDER BY GOODSID ) AS GOODSLISTCHECK 
	                FROM
		                TP_MST_GOODS 
	                WHERE
		                SECURITYCODECHECKFLAG = 1 
	                GROUP BY
	                SECURITYCODECHECKFLAG 
	                ) T3 ON T1.WJ = T3.WJ
                ";
                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>
        /// 通过条码和工序判断是绑定、验证还是普通处理
        /// </summary>
        /// <param name="barCode">产品条码</param>ram>
        /// <param name="procedureID">工序ID</param>ram>
        /// lsq 2021-11-22
        /// <returns>int</returns>
        public static ServiceResultEntity GetStatusByBarcode(string barCode, string procedureID, 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
											CASE	
												WHEN
													INSTR( ',' || T2.GOODSLISTBIND || ',', ',' || T0.GOODSCODE || ',' ) > 0 
													AND INSTR( ',' || T1.BINDPROCEDUREID || ',', ',' || :PROCEDUREID || ',' ) > 0 
													AND T4.COLLECTTYPE = 2 
													AND T4.MODELTYPE = 0 
												THEN
														1 
												WHEN 
													INSTR( ',' || T3.GOODSLISTCHECK || ',', ',' || T0.GOODSCODE || ',' ) > 0 
													AND INSTR( ',' || T1.CHECKROCEDUREID || ',', ',' || :PROCEDUREID || ',' ) > 0 
													AND T4.COLLECTTYPE = 2 
													AND T4.MODELTYPE = 0 
													-- AND EXISTS(SELECT 1 FROM TP_PM_PRODUCTIONDATA WHERE VALUEFLAG = 1 AND PROCEDUREID = 3 AND BARCODE = :BARCODE AND CREATETIME >= TO_DATE('2021-12-16 11:00:00', 'YYYY-MM-DD HH24:MI:SS'))
												THEN
														2 
												ELSE
														0 
												END AS STATUS 
											FROM
												(
												SELECT
													GD.GOODSCODE,
													1 AS WJ 
												FROM
													TP_PM_GROUTINGDAILYDETAIL GD
													LEFT JOIN TP_MST_GOODS G ON GD.GOODSID = G.GOODSID 
													WHERE
														GD.BARCODE = :BARCODE
														AND GD.VALUEFLAG = 1 
												) T0
												INNER JOIN (
												SELECT
													B.SETTINGVALUE AS BINDPROCEDUREID,
													C.SETTINGVALUE AS CHECKROCEDUREID,
													1 AS WJ 
												FROM
													TP_MST_SYSTEMSETTING B
													LEFT JOIN TP_MST_SYSTEMSETTING C ON C.SETTINGCODE = 'S_PM_031' 
												WHERE
													B.SETTINGCODE = 'S_PM_030' 
												) T1 ON T0.WJ = T1.WJ
												INNER JOIN (
												SELECT
													1 AS WJ,
													SECURITYCODEBINDFLAG,
													LISTAGG ( TO_CHAR( GOODSCODE ), ',' ) WITHIN GROUP ( ORDER BY GOODSID ) AS GOODSLISTBIND 
												FROM
													TP_MST_GOODS 
												WHERE
													SECURITYCODEBINDFLAG = 1 
												GROUP BY
													SECURITYCODEBINDFLAG 
												) T2 ON T1.WJ = T2.WJ
												LEFT JOIN (
												SELECT
													1 AS WJ,
													SECURITYCODECHECKFLAG,
													LISTAGG ( TO_CHAR( GOODSCODE ), ',' ) WITHIN GROUP ( ORDER BY GOODSID ) AS GOODSLISTCHECK 
												FROM
													TP_MST_GOODS 
												WHERE
													SECURITYCODECHECKFLAG = 1 
												GROUP BY
													SECURITYCODECHECKFLAG 
										        ) T3 ON T1.WJ = T3.WJ
												INNER JOIN (
												SELECT
													1 AS WJ,
													COLLECTTYPE,
													MODELTYPE 
												FROM
													TP_PC_PROCEDURE 
												WHERE
													PROCEDUREID = :PROCEDUREID 
										        ) T4 ON T1.WJ = T4.WJ
                    ";
                    OracleParameter[] paras = new OracleParameter[]{
                    new OracleParameter(":BARCODE",OracleDbType.Varchar2, barCode,ParameterDirection.Input),
                    new OracleParameter(":PROCEDUREID",OracleDbType.Int32, Convert.ToInt32(procedureID),ParameterDirection.Input),
                };

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

                    if (dt.Rows.Count > 0)
                    {
                        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>
        /// 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;
        }

        /// <summary>
        /// 通用读取产品信息方法 xuwei add 2021-09-14
        /// barCode可以接受防伪码进行查询 xuwei modi 2021-09-15
        /// </summary>
        /// <param name="barCode"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity GetGoodsByBarcode(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 OR GD.SECURITYCODE =:BARCODE )
	                        AND GD.VALUEFLAG =1
                    ";
                    OracleParameter[] paras = new OracleParameter[]{
                    new OracleParameter(":BARCODE",OracleDbType.Varchar2, barCode,ParameterDirection.Input),
                };

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

                    if (dt.Rows.Count>0)
                    {
                        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;
        }

        #endregion
    }
}