IMEX.mes.wcf/DK.Service/PDAModuleLogic/PDAModuleLogicWorkShop3.cs

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

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

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

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 = "";
            try
            {
                conn.Connect();
                //成型线注浆查询
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    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.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 EXISTS ( SELECT p.PURVIEWID FROM TP_MST_USERPURVIEW p WHERE p.PURVIEWTYPE = '6' AND ( p.PURVIEWID = - 1 OR p.PURVIEWID = l.GROUTINGLINEID ) AND u.USERCODE = '{sUser.UserCode}' ) --有操作权限
                            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>
        /// 成型线模具查询方法 E37 2#0101 2019-08-12 应用于 注资登记
        /// </summary>
        /// <param name="groutingLineCode"></param>
        /// <param name="groutingDay"></param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity GetGroutingLineDetail(string groutingLineCode, string groutingDay, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            try
            {
                conn.Connect();
                //查找成型线
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    AddServiceResultEntity(sre, GetGroutingLineInfo(groutingLineCode, groutingDay, sUser));
                }
                //检查注浆限制天数 'S_PM_021'
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT
	                        NVL(SETTINGVALUE,'0') 
                        FROM
	                        TP_MST_SYSTEMSETTING
                        WHERE
	                        SETTINGCODE = 'S_PM_021'
                            AND ACCOUNTID = {sUser.AccountID}
                    ";
                    int day = Convert.ToInt32(conn.GetSqlResultToStr(sqlStr));
                    if (day != 0)
                    {
                        DateTime groutingDate = Convert.ToDateTime(groutingDay);
                        DateTime beginDay = DateTime.Now.Date;
                        DateTime endDay = beginDay.AddDays(1 - day);
                        if (groutingDate < endDay || groutingDate > beginDay)
                        {
                            sre.Status = Constant.ServiceResultStatus.Other;
                            sre.OtherStatus = -1;
                            sre.Message = string.Format("允许注浆登记的日期范围【{0:yyyy-MM-dd}】-【{1:yyyy-MM-dd}】", endDay, beginDay);
                        }
                    }
                }
                //成型线模具查询
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    sqlStr = $@"
                        SELECT
	                        l.GROUTINGLINECODE,--AS 生产线编号,
	                        d.GROUTINGMOULDCODE,--AS 模具编号,
	                        g.GOODSCODE,--AS 产品编码,
	                        o.LOGONAME--AS 产品商标
                        FROM
	                        TP_PC_GROUTINGLINEDETAIL d
	                        LEFT JOIN TP_PC_GROUTINGLINE l ON l.GROUTINGLINEID = d.GROUTINGLINEID
	                        LEFT JOIN TP_MST_GOODS g ON g.GOODSID = d.GOODSID
	                        LEFT JOIN TP_MST_LOGO o ON o.LOGOID = g.LOGOID
                        WHERE
	                        d.VALUEFLAG = '1' 
	                        AND l.ACCOUNTID = {sUser.AccountID} 
	                        AND d.GMOULDSTATUS = 1 
	                        AND l.GROUTINGLINECODE = '{groutingLineCode}'
                        ORDER BY
	                        d.GROUTINGMOULDCODE
                        ";

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

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

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

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

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

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

                //校验工号 成型线工号配置的工号 必须包含当前用户
                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}'
                        ";

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

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

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

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

                }
                //插入 注浆记录
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    try
                    {
                        sqlStr = "BEGIN";

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

                        //按注浆次数循环 保存注浆记录
                        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 查询
                                {groutingBatchNo} + {i} + 1, --LASTGROUTINGBATCHNO 批次号 每注一次加1
                                l.MONITORID,
                                m.USERCODE AS MONITORCODE, --MONITORCODE 关联 TP_MST_USER 查询
                                l.HIGHPRESSUREFLAG
                            FROM
	                            TP_PC_GROUTINGLINE l
	                            LEFT JOIN TP_MST_GMOULDTYPE t ON l.GMOULDTYPEID = t.GMOULDTYPEID
	                            LEFT JOIN TP_MST_USER m ON l.MONITORID = m.USERID
                            WHERE
	                            GROUTINGLINECODE = '{jsonL["GROUTINGLINECODE"].ToString()}' --成型线号
                             AND l.VALUEFLAG = '1'
                             AND l.GMOULDSTATUS = 1
                            ;";

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

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

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

                                //更新注浆次数
                                sqlStr += $@"
                                UPDATE 
                                    TP_PC_GROUTINGLINEDETAIL
                                SET 
                                    GROUTINGCOUNT = GROUTINGCOUNT + {jsonM[j]["GROUTINGFLAG"].ToString()}
                                WHERE
                                    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 += "END;";

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

        /// <summary>
        /// 编辑注浆记录保存 ok
        /// </summary>
        /// <param name="groutingData">
            /*
             "groutingData": [
                 {
                     "GROUTINGDAILYDETAILID": "注浆日报ID1",
                     "GROUTINGFLAG": "注浆标识1",
                     "NOGROUTINGRREASON": "未注浆原因1"
                 },
                 {
                     "GROUTINGDAILYDETAILID": "注浆日报ID2",
                     "GROUTINGFLAG": "注浆标识2",
                     "NOGROUTINGRREASON": "未注浆原因2"
                 }
             ]
             */
        /// </param>
        /// <param name="sUser"></param>
        /// <returns></returns>
        public static ServiceResultEntity SetGroutingLineGrouting(string groutingData, SUserInfo sUser)
        {
            ServiceResultEntity sre = new ServiceResultEntity();
            sre.Data = new DataSet();
            sre.Status = Constant.ServiceResultStatus.Success;
            IDBTransaction conn = ClsDbFactory.CreateDBTransaction(DataBaseType.ORACLE, DataManager.ConnectionString);
            string sqlStr = "";
            int result = 0;
            try
            {
                conn.Connect();
                //更新注浆记录数据
                if (sre.Status == Constant.ServiceResultStatus.Success && groutingData != "")
                {
                    try
                    {
                        JArray json = JArray.Parse(groutingData);
                        string updateOne = $@"
                            UPDATE 
                                TP_PM_GROUTINGDAILYDETAIL
                            SET
                                GROUTINGFLAG = ':GROUTINGFLAG',
                                NOGROUTINGRREASON = :NOGROUTINGRREASON
                            WHERE
                                GROUTINGDAILYDETAILID = :GROUTINGDAILYDETAILID
                            ;
                            ";
                        sqlStr = "BEGIN";
                        for (int i=0;i<json.Count;i++)
                        {
                            //验证注浆原因,如果没给数据，置为空
                            if (!(json[i]["NOGROUTINGRREASON"] is object))
                                json[i]["NOGROUTINGRREASON"] = "null";

                            sqlStr += updateOne
                                .Replace(":GROUTINGFLAG", json[i]["GROUTINGFLAG"].ToString())
                                .Replace(":NOGROUTINGRREASON", json[i]["NOGROUTINGRREASON"].ToString())
                                .Replace(":GROUTINGDAILYDETAILID", json[i]["GROUTINGDAILYDETAILID"].ToString());
                            //sqlStr += ";";
                        }
                        sqlStr += "END;";
                        result = conn.ExecuteNonQuery(sqlStr);
                        sre.Status = Constant.ServiceResultStatus.Success;
                        sre.Message = "操作成功！";
                    }
                    catch
                    {
                        sre.Status = Constant.ServiceResultStatus.NoSearchResults;
                        sre.Message = "注浆记录保存失败！";
                    }
                }
                //更新成型线明细注浆次数
                if (sre.Status == Constant.ServiceResultStatus.Success && groutingData != "")
                {
                    try
                    {
                        JArray json = JArray.Parse(groutingData);
                        string updateOne = $@"
                            UPDATE 
                                TP_PC_GROUTINGLINEDETAIL
                            SET 
                                GROUTINGCOUNT = GROUTINGCOUNT + :GROUTINGCOUNT
                            WHERE 
                                GROUTINGLINEDETAILID = :GROUTINGLINEDETAILID
                            ;
                            ";
                        sqlStr = "BEGIN";
                        DataTable dt = new DataTable();
                        for (int i=0;i<json.Count;i++)
                        {
                            //读取原注浆记录进行比对，原来 注浆标识 为1 现在 注浆标识 为0 要-1 
                            dt = conn.GetSqlResultToDt($@"
                                SELECT  
                                    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());
                            }
                        }
                        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
                        ";
                    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 d.GROUTINGDATE = DATE '{groutingDay}' 
	                        AND d.GROUTINGBATCHNO = {groutingBatchNo}
                            AND d.GROUTINGFLAG = '1' -- 注浆标识
                            AND d.SCRAPFLAG = '0'  -- 损坯标识
                            AND d.BARCODE is null
                        ";

                    DataTable GroutingMouldCodeList = conn.GetSqlResultToDt(sqlStr);
                    //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();
                //检查注浆限制天数 '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();
            }
            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();
                //在产产品不可以报损
                if (sre.Status == Constant.ServiceResultStatus.Success)
                {
                    //报损时验证是否重复报损，撤销时验证是否重复撤销
                    sqlStr = $@"
                        SELECT 
                            COUNT(GROUTINGDAILYDETAILID) 
                        FROM
                            TP_PM_GROUTINGDAILYDETAIL
                        WHERE 
                            ACCOUNTID = {sUser.AccountID}
                            AND (BEGINNINGFLAG = '1' OR SCRAPFlAG = '{scrapFlag}') 
                            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";
                    sqlStr = $@"
                            UPDATE 
                                TP_PM_GROUTINGDAILYDETAIL
                            SET 
                                SCRAPFlAG = '{scrapFlag}',
                                SCRAPTYPE = {scrapType}
                            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();

            }
            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;
        }

        #endregion
    }
}